public static Task<List<EventuallyPin>> findAllPinned(Collection<String> excludeUUIDs) { ParseQuery<EventuallyPin> query = new ParseQuery<>(EventuallyPin.class) .fromPin(PIN_NAME) .ignoreACLs() .orderByAscending("time"); if (excludeUUIDs != null) { query.whereNotContainedIn("uuid", excludeUUIDs); } // We need pass in a null user because we don't want the query to fetch the current user // from LDS. return query.findInBackground().onSuccessTask(new Continuation<List<EventuallyPin>, Task<List<EventuallyPin>>>() { @Override public Task<List<EventuallyPin>> then(Task<List<EventuallyPin>> task) { final List<EventuallyPin> pins = task.getResult(); List<Task<Void>> tasks = new ArrayList<>(); for (EventuallyPin pin : pins) { ParseObject object = pin.getObject(); if (object != null) { tasks.add(object.fetchFromLocalDatastoreAsync().makeVoid()); } } return Task.whenAll(tasks).continueWithTask(new Continuation<Void, Task<List<EventuallyPin>>>() { @Override public Task<List<EventuallyPin>> then(Task<Void> task) { return Task.forResult(pins); } }); } }); }
@Override public Task<Boolean> existsAsync() { // We need to set `ignoreACLs` since we can't use ACLs without the current user. ParseQuery<T> query = ParseQuery.<T>getQuery(className) .fromPin(pinName) .ignoreACLs(); return query.countInBackground().onSuccessTask(new Continuation<Integer, Task<Boolean>>() { @Override public Task<Boolean> then(Task<Integer> task) { boolean exists = task.getResult() == 1; if (exists) { return Task.forResult(true); } return legacy.existsAsync(); } }); }
@Test public void testLimit() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); query.setLimit(5); assertEquals(5, query.getLimit()); }
@Test public void testWhereMatchesQuery() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); ParseQuery<ParseObject> conditionQuery = new ParseQuery<>("Test"); conditionQuery.whereExists("keyAgain"); query.whereMatchesQuery("key", conditionQuery); verifyCondition(query, "key", "$inQuery", conditionQuery.getBuilder()); }
public static Network findByMeetupId(String meetupId) { ParseQuery<Network> networkParseQuery = ParseQuery.getQuery(Network.class); // networkParseQuery.fromLocalDatastore(); // FIXME: get from local data store! return networkParseQuery.whereEqualTo( Network.MEETUP_GROUP_ID_KEY, meetupId).getFirstInBackground().getResult(); }
@Test public void testMultipleQueriesWithInflightChanges() throws ParseException { Parse.enableLocalDatastore(null); TestQueryController controller = new TestQueryController(); TaskCompletionSource<Void> tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); ParseCorePlugins.getInstance().registerQueryController(controller); List<Task<Void>> tasks = Arrays.asList( query.fromNetwork().findInBackground().makeVoid(), query.fromLocalDatastore().findInBackground().makeVoid(), query.setLimit(10).findInBackground().makeVoid(), query.whereEqualTo("key", "value").countInBackground().makeVoid()); assertTrue(query.isRunning()); tcs.trySetResult(null); ParseTaskUtils.wait(Task.whenAll(tasks)); assertFalse(query.isRunning()); }
ParseQuery<UserNotification> userNotificationParseQuery = ParseQuery.getQuery(UserNotification.class); userNotificationParseQuery.whereEqualTo(UserNotification.USER_ID_KEY, currentUser.getObjectId()); userNotificationParseQuery.whereEqualTo(UserNotification.ENABLED_KEY, true); userNotificationParseQuery.include(UserNotification.NOTIFICATION_KEY); userNotificationParseQuery.findInBackground(new FindCallback<UserNotification>() { @Override public void done(List<UserNotification> list, ParseException e) { ParseQuery<Post> postQuery = ParseQuery.getQuery(Post.class); ParseQuery<Subscribe> subscribeQuery = ParseQuery.getQuery(Subscribe.class); subscribeQuery.whereEqualTo(Subscribe.USER_KEY, currentUser); subscribeQuery.whereEqualTo(Subscribe.SUBSCRIBED_KEY, true); postQuery.fromPin(LocalDataStore.POSTS_PIN); ParseQuery<Post> postFeatureQuery = ParseQuery.getQuery(Post.class); postFeatureQuery.whereMatchesKeyInQuery(Post.FEATURE_KEY, Subscribe.FEATURE_KEY, subscribeQuery); ParseQuery<Post> postEventQuery = ParseQuery.getQuery(Post.class); postEventQuery.whereMatchesKeyInQuery(Post.EVENT_KEY, Subscribe.EVENT_KEY, subscribeQuery); postQuery = ParseQuery.or(subscribedFeaturesAndEvents); postQuery.orderByDescending(Post.AWESOME_COUNT_KEY); postQuery.include(Post.FEATURE_KEY); postQuery.include(Post.USER_KEY); postQuery.include(Post.EVENT_KEY); postQuery.findInBackground(new FindCallback<Post>() { public void done(List<Post> listPosts, ParseException e) { if (e != null) {
@Test public void testParseObservableAllNextAfterCompleted() { List<ParseUser> users = mocker(ParseUser.class).when(user -> user.getObjectId()).thenReturn(user -> String.valueOf(user.hashCode())).asList(3); rx.parse2.ParseObservable.all(mocker(ParseQuery.class) .when(query -> query.countInBackground()).thenReturn(query -> Task.forResult(users.size())) .when(query -> query.findInBackground()).thenReturn(query -> Task.forResult(users)) .when(query -> query.setSkip(any(int.class))).thenReturn(query -> null) .when(query -> query.setLimit(any(int.class))).thenReturn(query -> null).mock()) //.doOnNext(user -> System.out.println("" + ((ParseUser) user).getObjectId()))) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }
featureId = getArguments().getString(FEATURE_ID, ""); ParseQuery<Feature> featureParseQuery = ParseQuery.getQuery(Feature.class); postParseQuery = ParseQuery.getQuery(Post.class); if (!NetworkConnectivityReceiver.isNetworkAvailable(getContext())) { postParseQuery.fromPin(featureId); featureParseQuery.getInBackground(featureId, new GetCallback<Feature>() { @Override public void done(Feature f, ParseException e) {
@Test public void testIsRunning() { TestQueryController controller = new TestQueryController(); ParseCorePlugins.getInstance().registerQueryController(controller); TaskCompletionSource<Void> tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); assertFalse(query.isRunning()); query.findInBackground(); assertTrue(query.isRunning()); tcs.setResult(null); assertFalse(query.isRunning()); // Run another tcs = new TaskCompletionSource<>(); controller.await(tcs.getTask()); query.findInBackground(); assertTrue(query.isRunning()); query.cancel(); assertFalse(query.isRunning()); }
private void populateFeaturesList() { ParseQuery<Feature> query = ParseQuery.getQuery(Feature.class); query.fromPin(LocalDataStore.FEATURES_PIN); ParseQuery<Subscribe> subscribeParseQuery = ParseQuery.getQuery(Subscribe.class); subscribeParseQuery.whereEqualTo(Subscribe.USER_KEY, currentUser); subscribeParseQuery.whereExists(Subscribe.FEATURE_KEY); subscribeParseQuery.whereEqualTo(Subscribe.SUBSCRIBED_KEY, true); subscribeParseQuery.include("feature"); subscribeParseQuery.findInBackground(new FindCallback<Subscribe>() { @Override public void done(List<Subscribe> list, ParseException e) { ParseQuery<Recommendation> recommendationParseQuery = ParseQuery.getQuery(Recommendation.class); recommendationParseQuery.whereEqualTo(Recommendation.USER_ID_KEY, currentUser.getObjectId()); recommendationParseQuery.whereEqualTo(Recommendation.VALID_KEY, true); recommendationParseQuery.include("feature"); recommendationParseQuery.findInBackground(new FindCallback<Recommendation>() { @Override public void done(List<Recommendation> list, ParseException e) { query.findInBackground(new FindCallback<Feature>() { public void done(List<Feature> lFeatures, ParseException e) { if (e == null && lFeatures.size() > 0) {
private void autoSubscribeUserToTopics() { // Auto subscribe user to features final ArrayList<Feature> features = new ArrayList<>(); ParseQuery<Feature> featureQuery = ParseQuery.getQuery(Feature.class); featureQuery.whereEqualTo(Feature.AUTO_SUBSCRIBE_KEY, true); featureQuery.findInBackground(new FindCallback<Feature>() { public void done(List<Feature> featureList, ParseException e) { if (e == null) { for (int i = 0; i < featureList.size(); i++) { features.add(featureList.get(i)); } for (int j = 0; j < features.size(); j++) { Feature feature = features.get(j); final Subscribe subscribe = new Subscribe(); subscribe.setSubscribed(true); subscribe.setUser(currentUser); subscribe.setFeature(feature); subscribe.saveInBackground(); int subscribeCount = feature.getSubscribeCount() + 1; feature.setSubscribeCount(subscribeCount); feature.saveInBackground(); } } else { Log.d("AutoSubscribeError", "Error: " + e.getMessage()); } } }); }
public void updateLocation(){ final ParseGeoPoint userLocation = new ParseGeoPoint(location.getLatitude(), location.getLongitude()); ParseQuery<ParseObject> query = ParseQuery.getQuery("Requests"); query.whereDoesNotExist("driverUsername"); query.whereNear("requesterLocation", userLocation); query.setLimit(10); query.findInBackground(new FindCallback<ParseObject>() { @Override public void done(List<ParseObject> objects, ParseException e) { if ( e == null){ if(objects.size() > 0){ listViewContent.clear(); usernames.clear(); latitudes.clear(); longitudes.clear(); for (ParseObject object : objects){ Double distanceInMiles = userLocation.distanceInMilesTo((ParseGeoPoint) object.get("requesterLocation")); Double distaneOneDP = (double) Math.round(distanceInMiles *10) / 10; listViewContent.add(String.valueOf(distaneOneDP)+ " miles"); usernames.add(object.getString("requesterUsername")); latitudes.add(object.getParseGeoPoint("requesterLocation").getLatitude()); longitudes.add(object.getParseGeoPoint("requesterLocation").getLongitude()); } arrayAdapter.notifyDataSetChanged(); } } } }); } //restart the location updates on phone wake
@Override public Task<T> getAsync() { // We need to set `ignoreACLs` since we can't use ACLs without the current user. ParseQuery<T> query = ParseQuery.<T>getQuery(className) .fromPin(pinName) .ignoreACLs(); return query.findInBackground().onSuccessTask(new Continuation<List<T>, Task<T>>() { @Override public Task<T> then(Task<List<T>> task) { List<T> results = task.getResult(); if (results != null) { if (results.size() == 1) { return Task.forResult(results.get(0)); } else { return ParseObject.unpinAllInBackground(pinName).cast(); } } return Task.forResult(null); } }).onSuccessTask(new Continuation<T, Task<T>>() { @Override public Task<T> then(Task<T> task) { T ldsObject = task.getResult(); if (ldsObject != null) { return task; } return migrate(legacy, OfflineObjectStore.this).cast(); } }); }
@Test public void testMultipleQueries() { TestQueryController controller1 = new TestQueryController(); TestQueryController controller2 = new TestQueryController(); TaskCompletionSource<Void> tcs1 = new TaskCompletionSource<>(); TaskCompletionSource<Void> tcs2 = new TaskCompletionSource<>(); controller1.await(tcs1.getTask()); controller2.await(tcs2.getTask()); ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); query.setUser(new ParseUser()); ParseCorePlugins.getInstance().registerQueryController(controller1); query.findInBackground(); assertTrue(query.isRunning()); ParseCorePlugins.getInstance().reset(); ParseCorePlugins.getInstance().registerQueryController(controller2); query.countInBackground(); assertTrue(query.isRunning()); // Stop the first operation. tcs1.setResult(null); assertTrue(query.isRunning()); // Stop the second. tcs2.setResult(null); assertFalse(query.isRunning()); }
private void recommendUserToTopic() { // parse answers String[] parsed = userAns.split("\""); // query tags for answers ParseQuery<Tag> tagParseQuery = ParseQuery.getQuery(Tag.class); tagParseQuery.whereContainedIn(Tag.NAME_KEY, Arrays.asList(parsed)); // get features with those tags ParseQuery<FeatureTag> featureTagParseQuery = ParseQuery.getQuery(FeatureTag.class); featureTagParseQuery.whereMatchesQuery(FeatureTag.TAG_KEY, tagParseQuery); featureTagParseQuery.include("feature"); featureTagParseQuery.findInBackground(new FindCallback<FeatureTag>() { @Override public void done(List<FeatureTag> list, ParseException e) { if (e == null) { HashSet<Feature> featureSet = new HashSet<>(); // to catch dups! for (FeatureTag featureTag : list) { if (featureSet.add(featureTag.getFeature())) { // 0 and 3 // create recommendations Recommendation r = new Recommendation(); r.setFeature(featureTag.getFeature()); r.setFeatureId(featureTag.getFeature().getObjectId()); r.setUserId(currentUser.getObjectId()); r.setValid(true); r.saveInBackground(); } } } } }); }
private void registerUserNotifications() { ParseQuery<Notification> notificationParseQuery = ParseQuery.getQuery(Notification.class); notificationParseQuery.findInBackground(new FindCallback<Notification>() { @Override public void done(List<Notification> list, ParseException e) { if (e == null && list.size() > 0) { for (Notification n : list) { UserNotification un = new UserNotification(); un.setUserId(currentUser.getObjectId()); un.setEnabled(true); un.setNotification(n); un.saveInBackground(); } } } }); }
public void updateLocation(Location location){ if (requestActive) { final ParseGeoPoint userLocation = new ParseGeoPoint(location.getLatitude(), location.getLongitude()); ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("Requests"); query.whereEqualTo("requesterUsername", "1");//ParseUser.getCurrentUser().getUsername()); query.findInBackground(new FindCallback<ParseObject>() { @Override public void done(List<ParseObject> objects, ParseException e) { if (e == null) { if (objects.size() > 0) { for (ParseObject object : objects) { object.put("requesterLocation", userLocation); object.saveInBackground(); } } } } }); } } }
/** * Constructs a query for {@code ParseUser}. * * @see com.parse.ParseQuery#getQuery(Class) */ public static ParseQuery<ParseUser> getQuery() { return ParseQuery.getQuery(ParseUser.class); }
@Test public void testSetUser() throws ParseException { ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); ParseUser user = new ParseUser(); query.setUser(user); assertSame(user, ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); // TODO(grantland): Test that it gets the current user Parse.enableLocalDatastore(null); query.fromLocalDatastore() .ignoreACLs(); assertNull(ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); }