com.parse.ParseQuery Java Examples

@Override
public void call() {
    ParseQuery<ParseObject> query = ParseQuery.getQuery(ParseLikeTableDefinitions.PARSE_LIKE_TABLE);
    query.whereEqualTo(ParseLikeTableDefinitions.PARSE_LIKE_USER_ID, userId);

    query.findInBackground(new FindCallback<ParseObject>() {
        @Override
        public void done(List<ParseObject> parseLikes, ParseException e) {
            if (e == null) {
                if(parseLikes.size() > 0){
                    ParseObject likeObject = parseLikes.get(0);

                    likeObject.increment(ParseLikeTableDefinitions.PARSE_LIKE_NUM_LIKES);
                    likeObject.saveInBackground();
                }

                responseCallback.complete(userId);

            } else {
                LoggerProvider.getLogger().d(LOGTAG, "Error retrying info from parse");
            }
        }

    });
}
 

/**
 * Load the list of added friends into mFriends
 */
public void loadFriendsList() {
    mFriendsRelation = mCurrentUser.getRelation(ParseConstants.KEY_FRIENDS_RELATION);
    ParseQuery<ParseUser> query = mFriendsRelation.getQuery();
    query.addAscendingOrder(ParseConstants.KEY_USERNAME);
    query.findInBackground(new FindCallback<ParseUser>() {
        @Override
        public void done(List<ParseUser> friends, ParseException e) {
            if (e == null) {
                mFriends = friends;
                mAdapter = new FriendsAdapter();
                getListView().setAdapter(mAdapter);
                OyUtils.setListViewHeightBasedOnChildren(getListView());
                Log.d("friends", mFriends.size() + "");
            } else {
                Toast.makeText(MainActivity.this, getString(R.string.error_friends), Toast.LENGTH_SHORT).show();
            }
        }
    });
}
 

/**
 *  Limit 10000 by skip
 */
@NonNull
@CheckReturnValue
public static <R extends ParseObject> Observable<R> all(@NonNull final ParseQuery<R> query, int count) {
    final int limit = 1000; // limit limitation
    query.setSkip(0);
    query.setLimit(limit);
    Observable<R> find = find(query);
    for (int i = limit; i < count; i+= limit) {
        if (i >= 10000) break; // skip limitation
        query.setSkip(i);
        query.setLimit(limit);
        find.concatWith(find(query));
    }
    return find.distinct(o -> o.getObjectId());
}
 

@Override
protected void doBatchCrudRun(int count) throws Exception {
    List<ParseObject> list = new ArrayList<>(count);
    for (int i = 0; i < count; i++) {
        list.add(createEntity(i));
    }

    startClock();
    ParseObject.pinAll(list);
    stopClock(Benchmark.Type.BATCH_CREATE);

    startClock();
    ParseObject.pinAll(list);
    stopClock(Benchmark.Type.BATCH_UPDATE);

    startClock();
    List<ParseObject> reloaded = ParseQuery.getQuery("SimpleEntity")
            .fromLocalDatastore()
            .find();
    stopClock(Benchmark.Type.BATCH_READ);

    startClock();
    for (int i = 0; i < reloaded.size(); i++) {
        ParseObject entity = reloaded.get(i);
        entity.getBoolean("simpleBoolean");
        entity.getInt("simpleByte");
        entity.getInt("simpleShort");
        entity.getInt("simpleInt");
        entity.getLong("simpleLong");
        entity.getDouble("simpleFloat");
        entity.getDouble("simpleDouble");
        entity.getString("simpleString");
        entity.getBytes("simpleByteArray");
    }
    stopClock(Benchmark.Type.BATCH_ACCESS);

    startClock();
    deleteAll();
    stopClock(Benchmark.Type.BATCH_DELETE);
}
 

@Override
public void call() {
    ParseQuery<ParseObject> query = ParseQuery.getQuery(ParseLikeTableDefinitions.PARSE_LIKE_TABLE);
    query.whereContainedIn(ParseLikeTableDefinitions.PARSE_LIKE_USER_ID, userIds);

    query.findInBackground(new FindCallback<ParseObject>() {
        @Override
        public void done(List<ParseObject> parseLikes, ParseException e) {
            if (e == null) {
                GetLikesResponse response = new GetLikesResponse();

                for (ParseObject likeObject : parseLikes) {
                    String userId = likeObject.getString(ParseLikeTableDefinitions.PARSE_LIKE_USER_ID);
                    int numLikes = likeObject.getInt(ParseLikeTableDefinitions.PARSE_LIKE_NUM_LIKES);

                    response.add(userId, numLikes);
                }

                responseCallback.complete(response);

            } else {
                LoggerProvider.getLogger().d(LOGTAG, "Error retrying info from parse");
            }
        }

    });
}
 

private void getOldListItems(Date lastObjectCreatedAtDate) {

        ParseQuery<ParseObject> queryGetOldItems = ParseQuery.getQuery(dbToSearch);
        queryGetOldItems.whereEqualTo("newspaper_id", npIdString);
        queryGetOldItems.whereEqualTo("cat_id", catIdString);
        queryGetOldItems.whereLessThan("createdAt", lastObjectCreatedAtDate);
        queryGetOldItems.setLimit(20);
        queryGetOldItems.orderByDescending("createdAt");

        queryGetOldItems.findInBackground(new FindCallback<ParseObject>() {
            @Override
            public void done(List<ParseObject> articleObjectList, ParseException exception) {
                // Log.d(TAG, "Old Items articleObjectList " +
                // articleObjectList.size());
                if(exception == null){
                    retainedList.addAll(articleObjectList);
                    newsAdapter.notifyDataSetChanged();

                    // Log.d(TAG, "articleObjectList Retained " +
                    // retainedList.size());

                    mListView.removeFooterView(footerOnList);
                    mListViewContainer.setRefreshing(false);
                    flag_loading_old_data = false;
                } else {
                    Crashlytics.log("Wrong while fetching - " + exception.getMessage());
                    headerTextView.setText("Something went wrong!");
                }
            }

        });

    }
 

public static <T extends ParseObject> List<T> findAllParseObjects(ParseQuery<T> query) throws ParseException {
    List <T> result = new ArrayList<T>();
    query.setLimit(DEFAULT_PARSE_QUERY_LIMIT);
    List<T> chunk = null;
    do {
        chunk = query.find();
        result.addAll(chunk);
        query.setSkip(query.getSkip() + query.getLimit());
    } while (chunk.size() == query.getLimit());
    return result;
}
 

public static <T extends ParseObject> Task<List<T>> findAllParseObjectsAsync(final ParseQuery<T> query) {
    return Task.callInBackground(new Callable<List<T>>() {
        @Override
        public List<T> call() throws Exception {
            return findAllParseObjects(query);
        }
    });
}
 

private void indexedStringEntityQueriesRun(int count) throws ParseException {
    // create entities
    List<IndexedStringEntity> entities = new ArrayList<>(count);
    String[] fixedRandomStrings = StringGenerator.createFixedRandomStrings(count);
    for (int i = 0; i < count; i++) {
        IndexedStringEntity entity = new IndexedStringEntity();
        entity.setIndexedString(fixedRandomStrings[i]);
        entities.add(entity);
    }
    log("Built entities.");

    // insert entities
    ParseObject.pinAll(entities);
    log("Inserted entities.");

    // query for entities by indexed string at random
    int[] randomIndices = StringGenerator.getFixedRandomIndices(QUERY_COUNT, count - 1);

    startClock();
    for (int i = 0; i < QUERY_COUNT; i++) {
        int nextIndex = randomIndices[i];

        ParseQuery<IndexedStringEntity> query = ParseQuery.getQuery(IndexedStringEntity.class);
        query.whereEqualTo(IndexedStringEntity.INDEXED_STRING, fixedRandomStrings[nextIndex]);
        //noinspection unused
        List<IndexedStringEntity> result = query.find();
    }
    stopClock(Benchmark.Type.QUERY_INDEXED);

    // delete all entities
    ParseObject.unpinAll();
    log("Deleted all entities.");
}
 

@NonNull
@CheckReturnValue
public static <R extends ParseObject> Single<R> get(@NonNull final ParseQuery<R> query, @NonNull final String objectId) {
    return RxTask.single(() -> query.getInBackground(objectId));
}
 

@NonNull
public static Completable send(@NonNull final JSONObject data, @NonNull final ParseQuery<ParseInstallation> query) {
    return RxTask.completable(() -> ParsePush.sendDataInBackground(data, query));
}
 

@NonNull
public static Completable send(@NonNull final String message, @NonNull final ParseQuery<ParseInstallation> query) {
    return RxTask.completable(() -> ParsePush.sendMessageInBackground(message, query));
}
 

public static <T extends ParseObject> Task<List<T>> findAllParseObjectsAsync(Class<T> clazz) {
    return findAllParseObjectsAsync(ParseQuery.getQuery(clazz));
}
 

@NonNull
@CheckReturnValue
public static <R extends ParseObject> Single<R> get(@NonNull final Class<R> clazz, @NonNull final String objectId) {
    return get(ParseQuery.getQuery(clazz), objectId);
}
 

public static <T extends ParseObject> List<T> findAllParseObjects(Class<T> clazz) throws ParseException {
    return findAllParseObjects(ParseQuery.getQuery(clazz));
}
 

@NonNull
@CheckReturnValue
public static <R extends ParseObject> Single<R> first(@NonNull final ParseQuery<R> query) {
    return RxTask.single(() -> query.getFirstInBackground());
}
 

@NonNull
@CheckReturnValue
public static <R extends ParseObject> Observable<R> all(@NonNull final ParseQuery<R> query) {
    return count(query).flatMapObservable(c -> all(query, c));
}
 

private void getNewListItems() {

        mListViewContainer.setRefreshing(true);
        ParseQuery<ParseObject> queryGetNewItems = ParseQuery.getQuery(dbToSearch);
        queryGetNewItems.whereEqualTo("newspaper_id", npIdString);
        queryGetNewItems.whereEqualTo("cat_id", catIdString);
        queryGetNewItems.orderByDescending("createdAt");

        if (retainedList.size() > 0) {
            ParseObject topObject = retainedList.get(0);
            Date topObjectCreatedAt = topObject.getCreatedAt();
            queryGetNewItems.whereGreaterThan("createdAt", topObjectCreatedAt);
        }

        if (firstRun) {
            queryGetNewItems.setLimit(15);
        }
        //TODO: Try-catch with message
        queryGetNewItems.findInBackground(new FindCallback<ParseObject>() {
            @Override
            public void done(List<ParseObject> articleObjectList, ParseException exception) {

                if(exception == null){

                    retainedList.addAll(0, articleObjectList);

                    newsAdapter.notifyDataSetChanged();

                    dateLastUpdatedString = "Last Updated: "
                            + (DateUtils.formatDateTime(context, System.currentTimeMillis(), //
                            DateUtils.FORMAT_SHOW_TIME //
                                    | DateUtils.FORMAT_SHOW_WEEKDAY //
                                    | DateUtils.FORMAT_SHOW_DATE //
                                    | DateUtils.FORMAT_ABBREV_WEEKDAY //
                                    | DateUtils.FORMAT_NO_NOON //
                                    | DateUtils.FORMAT_NO_MIDNIGHT)); //
                    headerTextView.setText(dateLastUpdatedString);
                    mListViewContainer.setRefreshing(false);

                    if (mTwoPane) {
                        mListView.performItemClick(newsAdapter.getView(mActivatedPosition - 1, null, null),
                                mActivatedPosition, mActivatedPosition);

                    }
                    firstRun = false;
                } else {
                    Crashlytics.log("Wrong while fetching - " + exception.getMessage());
                    headerTextView.setText("Something went wrong!");
                }
            }

        });
    }
 

@NonNull
@CheckReturnValue
public static <R extends ParseObject> Single<Integer> count(@NonNull final ParseQuery<R> query) {
    return RxTask.single(() -> query.countInBackground());

}
 

@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));
}