@Override public Task<T> call() { return getUserAsync(state).onSuccessTask(new Continuation<ParseUser, Task<T>>() { @Override public Task<T> then(Task<ParseUser> task) { final ParseUser user = task.getResult(); return getFirstAsync(state, user, tcs.getTask()); } }); } }, tcs);
@Override public Task<List<T>> call() { return getUserAsync(state).onSuccessTask(new Continuation<ParseUser, Task<List<T>>>() { @Override public Task<List<T>> then(Task<ParseUser> task) { final ParseUser user = task.getResult(); return findAsync(state, user, tcs.getTask()); } }); } }, tcs);
@Override public Task<Integer> call() { return getUserAsync(state).onSuccessTask(new Continuation<ParseUser, Task<Integer>>() { @Override public Task<Integer> then(Task<ParseUser> task) { final ParseUser user = task.getResult(); return countAsync(state, user, tcs.getTask()); } }); } }, tcs);
@Override public Task<TResult> call() { return getUserAsync(state).onSuccessTask(new Continuation<ParseUser, Task<TResult>>() { @Override public Task<TResult> then(Task<ParseUser> task) { final ParseUser user = task.getResult(); final State<T> cacheState = new State.Builder<T>(state) .setCachePolicy(CachePolicy.CACHE_ONLY) .build(); final State<T> networkState = new State.Builder<T>(state) .setCachePolicy(CachePolicy.NETWORK_ONLY) .build(); Task<TResult> executionTask = delegate.call(cacheState, user, tcs.getTask()); executionTask = ParseTaskUtils.callbackOnMainThreadAsync(executionTask, callback); return executionTask.continueWithTask(new Continuation<TResult, Task<TResult>>() { @Override public Task<TResult> then(Task<TResult> task) { if (task.isCancelled()) { return task; } return delegate.call(networkState, user, tcs.getTask()); } }); } }); } }, tcs);
/** * Removes the previously cached result for this query, forcing the next find() to hit the * network. If there is no cached result for this query, then this is a no-op. */ //TODO (grantland): should be done Async since it does disk i/o & calls through to current user public void clearCachedResult() { throwIfLDSEnabled(); // TODO(grantland): Is there a more efficient way to accomplish this rather than building a // new state just to check it's cacheKey? State<T> state = builder.build(); ParseUser user = null; try { user = ParseTaskUtils.wait(getUserAsync(state)); } catch (ParseException e) { // do nothing } String sessionToken = user != null ? user.getSessionToken() : null; // TODO: Once the count queries are cached, handle the cached results of the count query. ParseKeyValueCache.clearFromKeyValueCache( ParseRESTQueryCommand.findCommand(state, sessionToken).getCacheKey() ); }
/** * Returns whether or not this query has a cached result. */ //TODO (grantland): should be done Async since it does disk i/o & calls through to current user public boolean hasCachedResult() { throwIfLDSEnabled(); // TODO(grantland): Is there a more efficient way to accomplish this rather than building a // new state just to check it's cacheKey? State<T> state = builder.build(); ParseUser user = null; try { user = ParseTaskUtils.wait(getUserAsync(state)); } catch (ParseException e) { // do nothing } String sessionToken = user != null ? user.getSessionToken() : null; /* * TODO: Once the count queries are cached, only return false when both queries miss in the * cache. */ String raw = ParseKeyValueCache.loadFromKeyValueCache( ParseRESTQueryCommand.findCommand(state, sessionToken).getCacheKey(), state.maxCacheAge() ); return raw != null; }
@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()))); }
@Test public void testCopy() { ParseQuery<ParseObject> query = new ParseQuery<>("TestObject"); query.setUser(new ParseUser()); query.whereEqualTo("foo", "bar"); ParseQuery.State.Builder<ParseObject> builder = query.getBuilder(); ParseQuery.State<ParseObject> state = query.getBuilder().build(); ParseQuery<ParseObject> queryCopy = new ParseQuery<>(query); ParseQuery.State.Builder<ParseObject> builderCopy = queryCopy.getBuilder(); ParseQuery.State<ParseObject> stateCopy = queryCopy.getBuilder().build(); assertNotSame(query, queryCopy); assertSame(query.getUserAsync(state).getResult(), queryCopy.getUserAsync(stateCopy).getResult()); assertNotSame(builder, builderCopy); assertSame(state.constraints().get("foo"), stateCopy.constraints().get("foo")); }