/** * Retrieves a list of {@link ParseObject}s that satisfy this query. * <p/> * * @return A list of all {@link ParseObject}s obeying the conditions set in this query. * @throws ParseException Throws a {@link ParseException} if no object is found. * @see ParseException#OBJECT_NOT_FOUND */ public List<T> find() throws ParseException { return ParseTaskUtils.wait(findInBackground()); }
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<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 testQueryCancellation() throws ParseException { 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()); Task<Void> task = query.findInBackground().makeVoid(); query.cancel(); tcs.setResult(null); try { ParseTaskUtils.wait(task); } catch (RuntimeException e) { assertThat(e.getCause(), instanceOf(CancellationException.class)); } // Should succeed task = query.findInBackground().makeVoid(); ParseTaskUtils.wait(task); }
private static <T extends ParseObject> Task<List<T>> findAsync( ParseQuery<T> query, final CancellationToken ct) { return query.findInBackground().continueWithTask(new Continuation<List<T>, Task<List<T>>>() { @Override public Task<List<T>> then(Task<List<T>> task) throws Exception { if (ct != null && ct.isCancellationRequested()) { return Task.cancelled(); } return task; } }); }
@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()); }
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(); } } } }); }
@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()); }
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(); } } } } }); } } }
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()); } } }); }
@Override public void done(Feature f, ParseException e) { feature = f; postParseQuery.whereEqualTo(Post.FEATURE_KEY, feature); postParseQuery.orderByDescending("createdAt"); postParseQuery.findInBackground(new FindCallback<Post>() { @Override public void done(List<Post> list, ParseException e) { if (e == null && list.size() > 0) { clear(); add(list); notifiedDataChanged(); clearSpinners(); LocalDataStore.unpinAndRepin(list, featureId); } else if (e != null) { Log.d("FEATURES_POST_FAIL", "Error: " + e.getMessage()); } else { clearSpinners(); noPostsView(feature.getHexColor()); } } }); } });
@Override public void done(Event event, ParseException e) { postParseQuery.whereEqualTo(Post.EVENT_KEY, event); postParseQuery.orderByDescending("createdAt"); postParseQuery.findInBackground(new FindCallback<Post>() { @Override public void done(List<Post> list, ParseException e) { if (e == null && list.size() > 0) { // clear adapter clear(); // add to adapter add(list); notifiedDataChanged(); clearSpinners(); // pin locally LocalDataStore.unpinAndRepin(list, eventId); } else if (e != null) { Log.d("PARSE_EVENTS_POST_FAIL", "Error: " + e.getMessage()); } else { clearSpinners(); noPostsView("#00b5a9"); // teal } } }); } });
public void Login(View view) { EditText etEmail = (EditText) findViewById(R.id.etEmail); msnackbar = (RelativeLayout) findViewById(R.id.email_login); String email = etEmail.getText().toString(); EditText etPassword = (EditText) findViewById(R.id.etPwd); final String pwd = etPassword.getText().toString(); ParseQuery<ParseUser> query = ParseUser.getQuery(); query.whereEqualTo("email", email); // query.findInBackground(new FindCallback<ParseUser>() { public void done(List<ParseUser> objects, ParseException e) { if (e == null) { if (objects.size() != 0) { ValidateUser(objects.get(0).getString("username"), pwd); }else{ Snackbar.make(msnackbar, getResources().getString(R.string.error_invalid_username_password), Snackbar.LENGTH_LONG).show(); } } else { Snackbar.make(msnackbar, getResources().getString(R.string.error_login_failed), Snackbar.LENGTH_LONG).show(); } } }); }
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(); } } } } }); }
@NonNull @CheckReturnValue public static <R extends ParseObject> Observable<R> find(@NonNull final ParseQuery<R> query) { return RxTask.observable(() -> query.findInBackground()) .flatMap(l -> Observable.fromIterable(l)); }
@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()); }
@Test public void testParseObservableFindNextAfterCompleted() { List<ParseUser> users = Arrays.asList(mock(ParseUser.class), mock(ParseUser.class), mock(ParseUser.class)); rx.parse2.ParseObservable.find(mocker(ParseQuery.class) .when(query -> query.findInBackground()).thenReturn(query -> Task.forResult(users)) .mock()) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }
@Test public void testBlockingFind() throws ParseException { List<ParseUser> users = Arrays.asList(mock(ParseUser.class), mock(ParseUser.class), mock(ParseUser.class)); ParseQuery<ParseUser> query = mocker(ParseQuery.class) .when(q -> q.findInBackground()).thenReturn(q -> Task.forResult(users)) .when(q -> { List<ParseUser> list = Collections.emptyList(); try { list = q.find(); } catch (Exception e) { } return list; }).thenReturn(q -> users) .mock(); assertThat(query.find()).isEqualTo(rx.parse2.ParseObservable.find(query).toList().blockingGet()); }
@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(); }
@Test public void testParseObservableAllForMass() { // FIXME: how mockito to make mass mocks? List<ParseUser> users = Observable.range(1, 1001) .map(i -> mocker(ParseUser.class).when(user -> user.getObjectId()).thenReturn(user -> "" + i + user.hashCode()).mock()) .toList() .blockingGet(); 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()) .test() .assertNoErrors() //.assertValue(check(l -> assertThat(l).isEqualTo(users))) .assertComplete(); }