Example usage for org.springframework.data.domain Pageable getSort

List of usage examples for org.springframework.data.domain Pageable getSort

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.domain.*
  5. Pageable
  6. getSort

Introduction

In this page you can find the example usage for org.springframework.data.domain Pageable getSort.

Prototype

Sort getSort();

Source Link

Document

Returns the sorting parameters.

Usage

From source file:com.mobileman.kuravis.core.services.entity.impl.AbstractEntityServiceImpl.java

@Override
public List<DBObject> findAllByQuery(String entityName, DBObject query, Pageable page) {

    if (query.containsField(EntityUtils.NAME)) {
        String name = (String) query.get(EntityUtils.NAME);
        query.put(EntityUtils.NAME,//w  ww  . j  a  v  a2s .co m
                new BasicDBObject("$regex", "^" + name.toLowerCase() + "$").append("$options", "i"));
    }

    DBCursor cursor = null;
    if (page.getSort() != null) {
        cursor = getCollection(entityName).find(query).sort(createSort(page)).skip(page.getOffset())
                .limit(page.getPageSize());
    } else {
        cursor = getCollection(entityName).find(query).skip(page.getOffset()).limit(page.getPageSize());
    }

    List<DBObject> result = cursor.toArray();
    return result;
}

From source file:com.epam.ta.reportportal.database.dao.ReportPortalRepositoryImpl.java

@Override
public long getPageNumber(String entityId, Filter filterable, Pageable pageable) {
    Class<T> javaType = this.getEntityInformation().getJavaType();
    ImmutableList.Builder<AggregationOperation> pipelineBuilder = ImmutableList.<AggregationOperation>builder()
            .add(new MatchOperation(
                    new Criteria().andOperator(toArray(toCriteriaList(filterable), Criteria.class))) {
                @Override//from   w  w w.  j  a v a2s .com
                public DBObject toDBObject(AggregationOperationContext context) {
                    return super.toDBObject(new TypeBasedAggregationOperationContext(javaType,
                            mongoOperations.getConverter().getMappingContext(), queryMapper));
                }
            });

    if (null != pageable.getSort()) {
        pipelineBuilder.add(
                /* sort results as requested */
                sort(pageable.getSort()));
    }

    pipelineBuilder.add(
            /* group items into one field pushing all results into one array */
            group("result").push("$_id").as("array"),
            /* unwind array adding index to each result */
            unwind("array", "ind", false),
            /* find needed item. How we know its index in query result */
            match(where("array").is(ObjectId.isValid(entityId) ? new ObjectId(entityId) : entityId)),
            /* grab index only */
            project("ind"));

    /* find items matching an provided filter */
    Aggregation a = Aggregation.newAggregation(toArray(pipelineBuilder.build(), AggregationOperation.class));

    final AggregationResults<Map> aggregate = mongoOperations.aggregate(a,
            getEntityInformation().getCollectionName(), Map.class);

    if (!aggregate.getUniqueMappedResult().containsKey("ind")) {
        throw new ReportPortalException(ErrorType.INCORRECT_FILTER_PARAMETERS,
                "Unable to calculate page number. Check your input parameters");
    }

    /* result returned as long. Calculate page number */
    return (long) Math.ceil((((Long) aggregate.getUniqueMappedResult().get("ind")).doubleValue() + 1d)
            / (double) pageable.getPageSize());
}

From source file:cn.guoyukun.spring.jpa.web.bind.method.annotation.PageableMethodArgumentResolver.java

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    PageableDefaults pageableDefaults = getPageableDefaults(parameter);
    //page request
    Pageable defaultPageRequest = getDefaultFromAnnotationOrFallback(pageableDefaults);

    String pageableNamePrefix = getPagePrefix(parameter);
    String sortNamePrefix = getSortPrefix(parameter);
    Map<String, String[]> pageableMap = getPrefixParameterMap(pageableNamePrefix, webRequest, true);
    Map<String, String[]> sortMap = getPrefixParameterMap(sortNamePrefix, webRequest, false);

    Sort sort = getSort(sortNamePrefix, sortMap, defaultPageRequest, webRequest);
    if (pageableMap.size() == 0) {
        return new PageRequest(defaultPageRequest.getPageNumber(), defaultPageRequest.getPageSize(),
                sort == null ? defaultPageRequest.getSort() : sort);
    }/*from   w w w .  j  av a2 s  . com*/

    int pn = getPn(pageableMap, defaultPageRequest);
    int pageSize = getPageSize(pageableMap, defaultPageRequest);

    return new PageRequest(pn - 1, pageSize, sort);

}

From source file:org.ngrinder.perftest.controller.PerfTestController.java

/**
 * Get the perf test lists.//  www  . j  a va2  s  .co  m
 *
 * @param user        user
 * @param query       query string to search the perf test
 * @param tag         tag
 * @param queryFilter "F" means get only finished, "S" means get only scheduled tests.
 * @param pageable    page
 * @param model       modelMap
 * @return perftest/list
 */
@RequestMapping({ "/list", "/", "" })
public String getAll(User user, @RequestParam(required = false) String query,
        @RequestParam(required = false) String tag, @RequestParam(required = false) String queryFilter,
        @PageableDefaults Pageable pageable, ModelMap model) {
    pageable = new PageRequest(pageable.getPageNumber(), pageable.getPageSize(),
            defaultIfNull(pageable.getSort(), new Sort(Direction.DESC, "lastModifiedDate")));
    Page<PerfTest> tests = perfTestService.getPagedAll(user, query, tag, queryFilter, pageable);
    annotateDateMarker(tests);
    model.addAttribute("tag", tag);
    model.addAttribute("availTags", tagService.getAllTagStrings(user, StringUtils.EMPTY));
    model.addAttribute("testListPage", tests);
    model.addAttribute("queryFilter", queryFilter);
    model.addAttribute("query", query);
    putPageIntoModelMap(model, pageable);
    return "perftest/list";
}

From source file:org.oncoblocks.centromere.web.controller.AbstractApiController.java

/**
 * Queries the repository using inputted query string paramters, defined within a annotated 
 *   {@link Model} classes.  Supports hypermedia, pagination, sorting, field 
 *   filtering, and field exclusion.//  w  w  w  . j a v  a 2s . c  o  m
 * 
 * @param pagedResourcesAssembler {@link PagedResourcesAssembler}
 * @param request {@link HttpServletRequest}
 * @return
 */
@RequestMapping(value = "", method = RequestMethod.GET, produces = { MediaType.APPLICATION_JSON_VALUE,
        ApiMediaTypes.APPLICATION_HAL_JSON_VALUE, ApiMediaTypes.APPLICATION_HAL_XML_VALUE,
        MediaType.APPLICATION_XML_VALUE, MediaType.TEXT_PLAIN_VALUE })
public HttpEntity<?> find(@PageableDefault(size = 1000) Pageable pageable,
        PagedResourcesAssembler<T> pagedResourcesAssembler, HttpServletRequest request) {
    ResponseEnvelope envelope;
    Set<String> fields = RequestUtils.getFilteredFieldsFromRequest(request);
    Set<String> exclude = RequestUtils.getExcludedFieldsFromRequest(request);
    pageable = RequestUtils.remapPageable(pageable, model);
    Map<String, String[]> parameterMap = request.getParameterMap();
    List<QueryCriteria> criterias = RequestUtils.getQueryCriteriaFromRequest(model, request);
    String mediaType = request.getHeader("Accept");
    Link selfLink = new Link(linkTo(this.getClass()).slash("").toString()
            + (request.getQueryString() != null ? "?" + request.getQueryString() : ""), "self");
    if (parameterMap.containsKey("page") || parameterMap.containsKey("size")) {
        Page<T> page = repository.find(criterias, pageable);
        if (ApiMediaTypes.isHalMediaType(mediaType)) {
            PagedResources<FilterableResource> pagedResources = pagedResourcesAssembler.toResource(page,
                    assembler, selfLink);
            envelope = new ResponseEnvelope(pagedResources, fields, exclude);
        } else {
            envelope = new ResponseEnvelope(page, fields, exclude);
        }
    } else {
        Sort sort = pageable.getSort();
        List<T> entities = null;
        if (sort != null) {
            entities = (List<T>) repository.find(criterias, sort);
        } else {
            entities = (List<T>) repository.find(criterias);
        }
        if (ApiMediaTypes.isHalMediaType(mediaType)) {
            List<FilterableResource> resourceList = assembler.toResources(entities);
            Resources<FilterableResource> resources = new Resources<>(resourceList);
            resources.add(selfLink);
            envelope = new ResponseEnvelope(resources, fields, exclude);
        } else {
            envelope = new ResponseEnvelope(entities, fields, exclude);
        }
    }
    return new ResponseEntity<>(envelope, HttpStatus.OK);
}

From source file:cn.guoyukun.spring.jpa.web.bind.method.annotation.PageableMethodArgumentResolver.java

private Sort getSort(String sortNamePrefix, Map<String, String[]> sortMap, Pageable defaultPageRequest,
        NativeWebRequest webRequest) {/*from  w  w  w.j a v  a 2s  . c o  m*/
    Sort sort = null;
    List<OrderedSort> orderedSortList = Lists.newArrayList();
    for (String name : sortMap.keySet()) {

        //sort1.abc
        int propertyIndex = name.indexOf(".") + 1;

        int order = 0;
        String orderStr = name.substring(sortNamePrefix.length(), propertyIndex - 1);
        try {
            if (!StringUtils.isEmpty(orderStr)) {
                order = Integer.valueOf(orderStr);
            }
        } catch (Exception e) {
        }

        String property = name.substring(propertyIndex);
        assertSortProperty(property);
        Sort.Direction direction = Sort.Direction.fromString(sortMap.get(name)[0]);

        orderedSortList.add(new OrderedSort(property, direction, order));
    }

    Collections.sort(orderedSortList);
    for (OrderedSort orderedSort : orderedSortList) {
        Sort newSort = new Sort(orderedSort.direction, orderedSort.property);
        if (sort == null) {
            sort = newSort;
        } else {
            sort = sort.and(newSort);
        }
    }

    if (sort == null) {
        return defaultPageRequest.getSort();
    }

    return sort;
}

From source file:org.openlmis.fulfillment.repository.custom.impl.OrderRepositoryImpl.java

private <T> CriteriaQuery<T> prepareQuery(CriteriaQuery<T> query, OrderSearchParams params,
        Set<UUID> processingPeriodIds, Pageable pageable, boolean count, Set<UUID> availableSupplyingFacilities,
        Set<UUID> availableRequestingFacilities) {
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    Root<Order> root = query.from(Order.class);

    if (count) {// w ww  . j a v  a  2 s.  c om
        CriteriaQuery<Long> countQuery = (CriteriaQuery<Long>) query;
        query = (CriteriaQuery<T>) countQuery.select(builder.count(root));
    }

    Predicate predicate = builder.conjunction();
    predicate = isEqual(SUPPLYING_FACILITY_ID, params.getSupplyingFacilityId(), root, predicate, builder);
    predicate = isEqual(REQUESTING_FACILITY_ID, params.getRequestingFacilityId(), root, predicate, builder);

    if (!(isEmpty(availableSupplyingFacilities) && isEmpty(availableRequestingFacilities))) {
        Predicate orPredicate = builder.disjunction();
        orPredicate = isOneOfOr(SUPPLYING_FACILITY_ID, availableSupplyingFacilities, root, orPredicate,
                builder);
        orPredicate = isOneOfOr(REQUESTING_FACILITY_ID, availableRequestingFacilities, root, orPredicate,
                builder);
        predicate = builder.and(predicate, orPredicate);
    }

    predicate = isEqual(PROGRAM_ID, params.getProgramId(), root, predicate, builder);
    predicate = isOneOf(PROCESSING_PERIOD_ID, processingPeriodIds, root, predicate, builder);
    predicate = isOneOf(ORDER_STATUS, params.getStatusAsEnum(), root, predicate, builder);

    query.where(predicate);

    if (!count && pageable != null && pageable.getSort() != null) {
        query = addSortProperties(query, root, pageable);
    }

    return query;
}

From source file:com.netflix.genie.core.jpa.services.JpaJobSearchServiceImpl.java

/**
 * {@inheritDoc}//from  ww w.  jav  a2s .  c  o m
 */
@Override
public Page<JobSearchResult> findJobs(final String id, final String jobName, final String user,
        final Set<JobStatus> statuses, final Set<String> tags, final String clusterName, final String clusterId,
        final String commandName, final String commandId, final Date minStarted, final Date maxStarted,
        final Date minFinished, final Date maxFinished, @NotNull final Pageable page) {
    log.debug("called");

    final CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
    final Root<JobEntity> root = countQuery.from(JobEntity.class);

    final Predicate whereClause = JpaJobSpecs.getFindPredicate(root, cb, id, jobName, user, statuses, tags,
            clusterName, clusterId == null ? null : this.clusterRepository.findOne(clusterId), commandName,
            commandId == null ? null : this.commandRepository.findOne(commandId), minStarted, maxStarted,
            minFinished, maxFinished);

    countQuery.select(cb.count(root)).where(whereClause);

    final Long count = this.entityManager.createQuery(countQuery).getSingleResult();

    // Use the count to make sure we even need to make this query
    if (count > 0) {
        final CriteriaQuery<JobSearchResult> contentQuery = cb.createQuery(JobSearchResult.class);
        contentQuery.from(JobEntity.class);

        contentQuery.multiselect(root.get(JobEntity_.id), root.get(JobEntity_.name), root.get(JobEntity_.user),
                root.get(JobEntity_.status), root.get(JobEntity_.started), root.get(JobEntity_.finished),
                root.get(JobEntity_.clusterName), root.get(JobEntity_.commandName));

        contentQuery.where(whereClause);

        final Sort sort = page.getSort();
        final List<Order> orders = new ArrayList<>();
        sort.iterator().forEachRemaining(order -> {
            if (order.isAscending()) {
                orders.add(cb.asc(root.get(order.getProperty())));
            } else {
                orders.add(cb.desc(root.get(order.getProperty())));
            }
        });

        contentQuery.orderBy(orders);

        final List<JobSearchResult> results = this.entityManager.createQuery(contentQuery)
                .setFirstResult(page.getOffset()).setMaxResults(page.getPageSize()).getResultList();

        return new PageImpl<>(results, page, count);
    } else {
        return new PageImpl<>(Lists.newArrayList(), page, count);
    }
}

From source file:com.mobileman.kuravis.core.services.entity.impl.AbstractEntityServiceImpl.java

@Override
public List<DBObject> findAll(String entityName, String projection, Pageable page) {
    if (page == null) {
        page = new PageRequest(0, Integer.MAX_VALUE);
    }/*www. jav a  2s  .c om*/

    DBCursor cursor = null;
    if (StringUtils.isEmpty(projection)) {
        cursor = getCollection(entityName).find(new BasicDBObject());
    } else {
        String[] properties = projection.split(",");
        BasicDBObjectBuilder projectionBuilder = BasicDBObjectBuilder.start();
        boolean idWanted = false;
        for (String property : properties) {
            property = property.trim();
            if (!StringUtils.isEmpty(property)) {
                if (property.equals(EntityUtils.ID)) {
                    idWanted = true;
                }

                projectionBuilder.add(property.trim(), true);
            }
        }

        if (idWanted == false) {
            projectionBuilder.append("_id", false);
        }

        cursor = getCollection(entityName).find(new BasicDBObject(), projectionBuilder.get())
                .sort(new BasicDBObject(projection, 1));
    }

    if (page.getSort() != null) {
        cursor = cursor.sort(createSort(page));
    } else if (projection != null) {
        cursor = cursor.sort(new BasicDBObject(projection, 1));
    }

    cursor = cursor.skip(page.getOffset()).limit(page.getPageSize());

    List<DBObject> result = cursor.toArray();
    return result;
}

From source file:ei.ne.ke.cassandra.cql3.AstyanaxCql3Repository.java

protected Page<T> doFindAll(ID restrict, Pageable pageable) {
    /*//from w  w w .jav a 2 s  .co  m
     * Example #1
     *   pageNumber = 0
     *   pageSize = 25
     *   offset = 0
     *   => start row = 0
     *   => end row = 24 (including)
     *
     * Example #2
     *   pageNumber = 1
     *   pageSize = 25
     *   offset = 0
     *   => start row = 25
     *   => end row = 49 (including)
     *
     * Example #3
     *   pageNumber = 1
     *   pageSize = 25
     *   offset = 10
     *   => start row = 35
     *   => end row = 59 (including)
     */
    try {
        int pageNumber = pageable.getPageNumber();
        int pageSize = pageable.getPageSize();
        int offset = pageable.getOffset();
        int firstRow = pageNumber * pageSize + offset;
        int lastRow = (pageNumber + 1) * pageSize + offset;
        Map<String, ByteBuffer> serializedKeyValues = spec.getSerializedKeyValues(restrict);
        List<String> keysSet = EntitySpecificationUtils.getKeysSet(serializedKeyValues);
        String keysCql = cqlGen.buildLimitedFindAllKeysStatement(keysSet, pageable.getSort(), lastRow);
        PreparedCqlQuery<String, String> preparedStatement = doPreparedCqlRead(keysCql);
        for (String column : keysSet) {
            preparedStatement = preparedStatement.withValue(serializedKeyValues.get(column));
        }
        OperationResult<CqlResult<String, String>> keysResult = preparedStatement.execute();
        LOGGER.debug("attempts: {}, latency: {}ms", keysResult.getAttemptsCount(),
                keysResult.getLatency(TimeUnit.MILLISECONDS));
        CqlResult<String, String> cqlKeysResult = keysResult.getResult();
        Rows<String, String> keysSetRows = cqlKeysResult.getRows();
        List<T> keysAsEnts = Lists.newArrayListWithExpectedSize(lastRow - firstRow + 1);
        for (int i = firstRow; i < keysSetRows.size() && i < lastRow; i++) {
            keysAsEnts.add(spec.map(keysSetRows.getRowByIndex(i).getColumns()));
        }
        List<ID> keys = spec.getKey(keysAsEnts);
        return new PageImpl<T>((List<T>) findAll(keys), pageable, count(restrict));
    } catch (ConnectionException e) {
        throw new DataRetrievalFailureException("Error while executing CQL3 query", e);
    }
}