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

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

Introduction

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

Prototype

int getPageSize();

Source Link

Document

Returns the number of items to be returned.

Usage

From source file:org.springframework.cloud.dataflow.server.service.impl.AbstractStreamService.java

@Override
public Page<StreamDefinition> findDefinitionByNameLike(Pageable pageable, String search) {
    Page<StreamDefinition> streamDefinitions;
    if (search != null) {
        final SearchPageable searchPageable = new SearchPageable(pageable, search);
        searchPageable.addColumns("DEFINITION_NAME", "DEFINITION");
        streamDefinitions = streamDefinitionRepository.findByNameLike(searchPageable);
        long count = streamDefinitions.getContent().size();
        long to = Math.min(count, pageable.getOffset() + pageable.getPageSize());
        streamDefinitions = new PageImpl<>(streamDefinitions.getContent(), pageable,
                streamDefinitions.getTotalElements());
    } else {//from  w  w w. ja va 2s  .  c  o  m
        streamDefinitions = streamDefinitionRepository.findAll(pageable);
    }
    return streamDefinitions;
}

From source file:org.springframework.cloud.dataflow.server.stream.AppDeployerStreamDeployer.java

@Override
public Page<AppStatus> getAppStatuses(Pageable pageable) throws ExecutionException, InterruptedException {

    Iterable<StreamDefinition> streamDefinitions = this.streamDefinitionRepository.findAll();
    Iterable<StreamDeployment> streamDeployments = this.streamDeploymentRepository.findAll();

    List<String> appDeployerStreams = new ArrayList<>();
    for (StreamDeployment streamDeployment : streamDeployments) {
        appDeployerStreams.add(streamDeployment.getStreamName());

    }// w  w  w. j a  va2  s  . c  o  m

    List<StreamDefinition> appDeployerStreamDefinitions = new ArrayList<>();
    for (StreamDefinition streamDefinition : streamDefinitions) {
        if (appDeployerStreams.contains(streamDefinition.getName())) {
            appDeployerStreamDefinitions.add(streamDefinition);
        }
    }

    // First build a sorted list of deployment id's so that we have a predictable paging order.
    List<String> deploymentIds = appDeployerStreamDefinitions.stream()
            .flatMap(sd -> sd.getAppDefinitions().stream()).flatMap(sad -> {
                String key = DeploymentKey.forStreamAppDefinition(sad);
                String id = this.deploymentIdRepository.findOne(key);
                return id != null ? Stream.of(id) : Stream.empty();
            }).sorted(String::compareTo).collect(Collectors.toList());

    // Running this this inside the FJP will make sure it is used by the parallel stream
    // Skip first items depending on page size, then take page and discard rest.
    List<AppStatus> content = this.forkJoinPool.submit(() -> deploymentIds.stream()
            .skip(pageable.getPageNumber() * pageable.getPageSize()).limit(pageable.getPageSize()).parallel()
            .map(appDeployer::status).collect(Collectors.toList())).get();
    return new PageImpl<>(content, pageable, deploymentIds.size());
}

From source file:org.springframework.cloud.dataflow.server.stream.SkipperStreamDeployer.java

@Override
public Page<AppStatus> getAppStatuses(Pageable pageable) {
    List<String> skipperStreams = new ArrayList<>();
    Iterable<StreamDefinition> streamDefinitions = this.streamDefinitionRepository.findAll();
    for (StreamDefinition streamDefinition : streamDefinitions) {
        skipperStreams.add(streamDefinition.getName());
    }/*from   ww w .  j  ava2 s .co m*/

    List<AppStatus> allStatuses = getStreamsStatuses(skipperStreams);

    List<AppStatus> pagedStatuses = allStatuses.stream().skip(pageable.getPageNumber() * pageable.getPageSize())
            .limit(pageable.getPageSize()).parallel().collect(Collectors.toList());

    return new PageImpl<>(pagedStatuses, pageable, allStatuses.size());
}

From source file:org.springframework.data.document.mongodb.repository.QueryDslMongoRepository.java

/**
 * Applies the given {@link Pageable} to the given {@link MongodbQuery}.
 * /*from   w w  w .j a  va 2 s .c o m*/
 * @param query
 * @param pageable
 * @return
 */
private MongodbQuery<T> applyPagination(MongodbQuery<T> query, Pageable pageable) {

    if (pageable == null) {
        return query;
    }

    query = query.offset(pageable.getOffset()).limit(pageable.getPageSize());
    return applySorting(query, pageable.getSort());
}

From source file:org.springframework.data.jpa.repository.support.SimpleJpaRepository.java

/**
 * Reads the given {@link TypedQuery} into a {@link Page} applying the given {@link Pageable} and
 * {@link Specification}.//from w w w.  j  ava2 s .  co  m
 * 
 * @param query must not be {@literal null}.
 * @param spec can be {@literal null}.
 * @param pageable can be {@literal null}.
 * @return
 */
protected Page<T> readPage(TypedQuery<T> query, Pageable pageable, Specification<T> spec) {

    query.setFirstResult(pageable.getOffset());
    query.setMaxResults(pageable.getPageSize());

    Long total = QueryUtils.executeCountQuery(getCountQuery(spec));
    List<T> content = total > pageable.getOffset() ? query.getResultList() : Collections.<T>emptyList();

    return new PageImpl<T>(content, pageable, total);
}

From source file:org.springframework.xd.dirt.util.PagingUtility.java

/**
 * Get the paged data of the given list.
 *
 * @param pageable the paging information, must not be null
 * @param list the list of content to paginate, must not be null
 * @return the paginated implementation of the given list of <T>
 * @throws PageNotFoundException in case an invalid page is requested
 *//*from  w  ww .ja va  2s . c om*/
public Page<T> getPagedData(Pageable pageable, List<T> list) throws PageNotFoundException {

    Assert.notNull(pageable, "Pagination info can't be null.");
    Assert.notNull(list, "The provided list must not be null.");

    final int offset = pageable.getOffset();
    final int to = Math.min(list.size(), offset + pageable.getPageSize());

    if (offset > to) {
        throw new PageNotFoundException(String.format("Page %s does not exist.", pageable.getPageNumber()));
    }

    if (CollectionUtils.isEmpty(list)) {
        return new PageImpl<T>(list);
    }

    Collections.sort(list);

    final List<T> data = list.subList(offset, to);
    return new PageImpl<T>(data, pageable, list.size());
}

From source file:piecework.persistence.concrete.SearchRepositoryProvider.java

@Override
public SearchResponse forms(SearchCriteria criteria, ViewContext context, boolean excludeData)
        throws PieceworkException {
    long time = 0;
    if (LOG.isDebugEnabled())
        time = System.currentTimeMillis();

    Set<String> overseerProcessDefinitionKeys = principal.getProcessDefinitionKeys(AuthorizationRole.OVERSEER);
    Set<String> userProcessDefinitionKeys = principal.getProcessDefinitionKeys(AuthorizationRole.USER);

    Set<String> allProcessDefinitionKeys = Sets.union(overseerProcessDefinitionKeys, userProcessDefinitionKeys);
    Set<piecework.model.Process> allowedProcesses = processes(allProcessDefinitionKeys);

    SearchResponse response = new SearchResponse();

    if (allowedProcesses == null || allowedProcesses.isEmpty())
        return response;

    List<Process> alphabetical = new ArrayList<Process>(allowedProcesses);
    Collections.sort(alphabetical, new Comparator<Process>() {
        @Override/*from w  w w.  ja va  2  s .  com*/
        public int compare(Process o1, Process o2) {
            if (org.apache.commons.lang.StringUtils.isEmpty(o1.getProcessDefinitionLabel()))
                return 0;
            if (org.apache.commons.lang.StringUtils.isEmpty(o2.getProcessDefinitionLabel()))
                return 1;
            return o1.getProcessDefinitionLabel().compareTo(o2.getProcessDefinitionLabel());
        }
    });

    List<Map<String, String>> metadata = new ArrayList<Map<String, String>>();
    Set<String> pgs = new HashSet<String>();
    for (Process allowedProcess : alphabetical) {
        if (allowedProcess.getProcessDefinitionKey() != null) {
            Process definition = allowedProcess;
            Form form = new Form.Builder().processDefinitionKey(definition.getProcessDefinitionKey())
                    .task(new Task.Builder().processDefinitionKey(definition.getProcessDefinitionKey())
                            .processDefinitionLabel(definition.getProcessDefinitionLabel()).build(context))
                    .build(context);
            Map<String, String> map = new HashMap<String, String>();
            map.put("processDefinitionKey", definition.getProcessDefinitionKey());
            map.put("processDefinitionLabel", definition.getProcessDefinitionLabel());
            map.put("link", form.getLink());
            metadata.add(map);
            if (StringUtils.isNotEmpty(allowedProcess.getProcessGroup())) {
                pgs.add(allowedProcess.getProcessGroup());
            }
        }
    }
    response.setMetadata(metadata);

    // bucket list stuff
    String pg = null;

    // get process group from allowed processes
    if (pgs.size() == 1) {
        pg = pgs.toArray()[0].toString();
    } else {
        // then try to get process group from query
        Map<String, List<String>> contentParameter = criteria.getContentParameters();
        if (contentParameter != null) {
            List<String> vlist = contentParameter.get("pg");
            if (vlist != null && vlist.size() > 0) {
                pg = vlist.get(0);
            }
        }
    }

    if (StringUtils.isNotEmpty(pg) && bucketListRepository != null) {
        BucketList bucketList = bucketListRepository.findOne(pg);
        if (bucketList != null) {
            response.setBucketList(bucketList);
        }
        response.setProcessGroup(pg);
    }

    String processStatus = criteria.getProcessStatus() != null ? sanitizer.sanitize(criteria.getProcessStatus())
            : Constants.ProcessStatuses.OPEN;
    String taskStatus = criteria.getTaskStatus() != null ? sanitizer.sanitize(criteria.getTaskStatus())
            : Constants.TaskStatuses.ALL;

    List<TaskDeployment> taskDeployments = new ArrayList<TaskDeployment>();
    Set<String> userIds = new HashSet<String>();

    List<Facet> facets = FacetFactory.facets(allowedProcesses);
    response.setFacets(facets);

    Map<DataFilterFacet, String> filterFacetParameters = criteria.getFilterFacetParameters();

    if (!excludeData) {
        Query query = new SearchQueryBuilder(criteria).build(allProcessDefinitionKeys, sanitizer);

        int instancePageNumber = 0;
        int instancePageSize = 1000;
        Sort sort = SearchUtility.sort(criteria, sanitizer);
        Pageable pageable = new PageRequest(instancePageNumber, instancePageSize, sort);
        Page<ProcessInstance> page = instanceRepository.findByQuery(query, pageable, true);

        int pageNumber = criteria.getPageNumber() != null ? criteria.getPageNumber().intValue() : 0;
        int pageSize = criteria.getPageSize() != null ? criteria.getPageSize() : 200;
        Pageable taskPageable = new PageRequest(pageNumber, pageSize);
        long total = page.getTotalElements();
        long taskCounter = 0;
        long instanceCounter = 0;
        long start = taskPageable.getOffset();
        long end = taskPageable.getOffset() + taskPageable.getPageSize();

        while (instanceCounter < total && page.hasContent()) {
            // Loop again through the list to get all user ids and build the intermediate object including
            // task, instance, and deployment
            for (ProcessInstance instance : page.getContent()) {
                String processDefinitionKey = instance.getProcessDefinitionKey();
                String processInstanceId = instance.getProcessInstanceId();

                instanceCounter++;

                ProcessDeployment processDeployment = null;

                Map<String, Object> instanceData = new HashMap<String, Object>();

                instanceData.put("processInstanceId", processInstanceId);
                instanceData.put("processInstanceLabel", instance.getProcessInstanceLabel());
                instanceData.put("processDefinitionLabel", instance.getProcessDefinitionLabel());
                instanceData.put("processStatus", instance.getProcessStatus());
                instanceData.put("applicationStatusExplanation", instance.getApplicationStatusExplanation());
                instanceData.put("startTime", instance.getStartTime());
                instanceData.put("lastModifiedTime", instance.getLastModifiedTime());
                instanceData.put("endTime", instance.getEndTime());

                String activation = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, "activation");
                String attachment = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, Attachment.Constants.ROOT_ELEMENT_NAME);
                String cancellation = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, "cancellation");
                String history = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, History.Constants.ROOT_ELEMENT_NAME);
                String restart = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, "restart");
                String suspension = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, "suspension");
                String bucketUrl = context.getApplicationUri(ProcessInstance.Constants.ROOT_ELEMENT_NAME,
                        processDefinitionKey, processInstanceId, "value/Bucket");

                instanceData.put("activation", activation);
                instanceData.put("attachment", attachment);
                instanceData.put("cancellation", cancellation);
                instanceData.put("history", history);
                instanceData.put("restart", restart);
                instanceData.put("suspension", suspension);
                instanceData.put("bucketUrl", bucketUrl);

                Map<String, List<Value>> valueData = instance.getData();
                if (valueData != null && !valueData.isEmpty()) {
                    for (Facet facet : facets) {
                        if (facet instanceof DataSearchFacet) {
                            DataSearchFacet dataSearchFacet = DataSearchFacet.class.cast(facet);
                            String name = dataSearchFacet.getName();
                            String value = ProcessInstanceUtility.firstString(name, valueData);
                            if (StringUtils.isNotEmpty(value))
                                instanceData.put(name, value);
                        }
                    }
                }

                Set<Task> tasks = instance.getTasks();
                if (tasks != null && !tasks.isEmpty()) {
                    for (Task task : tasks) {
                        if (include(task, processStatus, taskStatus, overseerProcessDefinitionKeys,
                                principal)) {
                            if (taskCounter >= start && taskCounter < end) {
                                taskDeployments.add(new TaskDeployment(taskCounter, processDeployment, instance,
                                        task, instanceData));
                                userIds.addAll(task.getAssigneeAndCandidateAssigneeIds());
                            }
                            taskCounter++;
                        }
                    }
                }
            }

            if (total > instanceCounter) {
                instancePageNumber++;
                Pageable nextPage = new PageRequest(instancePageNumber, instancePageSize, sort);
                page = instanceRepository.findByQuery(query, nextPage, false);
            }
        }

        response.setTotal((int) taskCounter);
        response.setPageNumber(taskPageable.getPageNumber());
        response.setPageSize(taskPageable.getPageSize());
    }

    Map<String, User> userMap = identityService.findUsers(userIds);

    List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();

    for (TaskDeployment taskDeployment : taskDeployments) {
        Map<String, Object> map = new HashMap<String, Object>();
        Map<String, Object> instanceData = taskDeployment.getInstanceData();

        if (instanceData != null && !instanceData.isEmpty())
            map.putAll(instanceData);

        Task task = TaskFactory.task(taskDeployment.getTask(), new PassthroughSanitizer(), userMap, context);
        String processDefinitionKey = task.getProcessDefinitionKey();

        if (!include(task, filterFacetParameters))
            continue;

        map.put("itemNumber", taskDeployment.getItemNumber());
        map.put("assignee", task.getAssignee());
        map.put("candidateAssignees", task.getCandidateAssignees());

        map.put("formInstanceId", task.getTaskInstanceId());
        map.put("taskId", task.getTaskInstanceId());
        map.put("taskClaimTime", task.getClaimTime());
        map.put("taskDueDate", task.getDueDate());
        map.put("taskStartTime", task.getStartTime());
        map.put("taskEndTime", task.getEndTime());
        map.put("taskLabel", task.getTaskLabel());
        map.put("taskDescription", task.getTaskDescription());
        map.put("taskStatus", task.getTaskStatus());
        map.put("active", task.isActive());

        String assignment = context != null && task != null && task.getTaskInstanceId() != null
                ? context.getApplicationUri(Task.Constants.ROOT_ELEMENT_NAME, processDefinitionKey,
                        task.getTaskInstanceId(), "assign")
                : null;

        map.put("assignment", assignment);
        map.put("link",
                context != null
                        ? context.getApplicationUri(Form.Constants.ROOT_ELEMENT_NAME, processDefinitionKey)
                                + "?taskId=" + task.getTaskInstanceId()
                        : null);
        data.add(map);
    }
    List<FacetSort> postQuerySortBy = criteria.getPostQuerySortBy();
    if (postQuerySortBy != null && !postQuerySortBy.isEmpty()) {
        Collections.reverse(postQuerySortBy);
        for (FacetSort facetSort : postQuerySortBy) {
            Collections.sort(data, new DataFilterFacetComparator(facetSort.getFacet()));
            if (facetSort.getDirection().equals(Sort.Direction.DESC))
                Collections.reverse(data);
        }
    }

    response.setData(data);

    List<FacetSort> facetSortList = criteria.getSortBy();
    List<String> sortBy = new ArrayList<String>();
    if (facetSortList != null) {
        for (FacetSort facetSort : facetSortList) {
            sortBy.add(facetSort.toString());
        }
    }
    response.setSortBy(sortBy);

    if (LOG.isDebugEnabled())
        LOG.debug("Retrieved forms in " + (System.currentTimeMillis() - time) + " ms");

    if (principal instanceof User)
        response.setCurrentUser(User.class.cast(principal));

    return response;
}

From source file:piecework.repository.concrete.ProcessInstanceRepositoryCustomImpl.java

@Override
public Page<ProcessInstance> findByQueryParameters(Set<String> processDefinitionKeys,
        SearchQueryParameters queryParameters, Pageable pageable, Sanitizer sanitizer) {
    // Otherwise, look up all instances that match the query
    Query query = SearchUtility.query(queryParameters, processDefinitionKeys, sanitizer);
    query.skip(pageable.getOffset());// w w  w  . j  a  v a  2s .c  o  m
    query.limit(pageable.getPageSize());

    org.springframework.data.mongodb.core.query.Field field = query.fields();

    // Don't include form data in the result unless it's requested
    //        if (! criteria.isIncludeVariables())
    field.exclude("data");

    return findByQuery(query, pageable, true);
}

From source file:piecework.task.TaskPageHandler.java

public SearchResults handle(Page<ProcessInstance> page, Pageable pageable, Set<Process> allowedProcesses) {
    SearchResults.Builder resultsBuilder = new SearchResults.Builder().resourceLabel("Tasks")
            .resourceName(Form.Constants.ROOT_ELEMENT_NAME).link(version.getApplicationUri());

    if (allowedProcesses == null || allowedProcesses.isEmpty())
        return resultsBuilder.build(version);

    List<Process> alphabetical = new ArrayList<Process>(allowedProcesses);
    Collections.sort(alphabetical, new Comparator<Process>() {
        @Override//w  w  w  .j  ava2s.  com
        public int compare(Process o1, Process o2) {
            if (org.apache.commons.lang.StringUtils.isEmpty(o1.getProcessDefinitionLabel()))
                return 0;
            if (org.apache.commons.lang.StringUtils.isEmpty(o2.getProcessDefinitionLabel()))
                return 1;
            return o1.getProcessDefinitionLabel().compareTo(o2.getProcessDefinitionLabel());
        }
    });
    for (Process allowedProcess : alphabetical) {
        if (allowedProcess.getProcessDefinitionKey() != null) {
            Process definition = new Process.Builder(allowedProcess, sanitizer).build(version);
            if (taskFilter.isWrapWithForm()) {
                resultsBuilder.definition(new Form.Builder()
                        .processDefinitionKey(definition.getProcessDefinitionKey())
                        .task(new Task.Builder().processDefinitionKey(definition.getProcessDefinitionKey())
                                .processDefinitionLabel(definition.getProcessDefinitionLabel()).build(version))
                        .build(version));
            } else {
                resultsBuilder.definition(definition);
            }
        }
    }

    if (page.hasContent()) {
        int count = 0;

        // Loop once through list to get the deployment ids
        Set<String> deploymentIds = taskFilter.getDeploymentIds(page.getContent());

        // Retrieve a map of deployment objects from Mongo
        //            Map<String, ProcessDeployment> deploymentMap = getDeploymentMap(deploymentIds);

        List<TaskDeployment> rawTasks = new ArrayList<TaskDeployment>();
        Set<String> userIds = new HashSet<String>();

        // Loop again through the list to get all user ids and build the intermediate object including
        // task, instance, and deployment
        for (ProcessInstance instance : page.getContent()) {
            ProcessDeployment processDeployment = null;
            //                if (taskFilter.isWrapWithForm())
            //                    processDeployment = deploymentMap.get(instance.getDeploymentId());

            Set<Task> tasks = instance.getTasks();
            if (tasks != null && !tasks.isEmpty()) {
                for (Task task : tasks) {
                    if (taskFilter.include(task, processStatus, taskStatus)) {
                        rawTasks.add(new TaskDeployment(0, processDeployment, instance, task));
                        userIds.addAll(task.getAssigneeAndCandidateAssigneeIds());
                    }
                }
            }
        }

        Map<String, User> userMap = getUserMap(userIds);

        for (TaskDeployment rawTask : rawTasks) {
            resultsBuilder.item(taskFilter.result(rawTask, userMap, version));
            count++;
        }

        resultsBuilder.firstResult(pageable.getOffset());
        resultsBuilder.maxResults(pageable.getPageSize());
        resultsBuilder.total(Long.valueOf(count));
    }
    if (taskFilter.getPrincipal() != null && taskFilter.getPrincipal() instanceof User)
        resultsBuilder.currentUser(User.class.cast(taskFilter.getPrincipal()));

    return resultsBuilder.build(version);
}

From source file:siddur.solidtrust.autoscout.AutoscoutService.java

public Page<ScoutCar> timeOnSale(Pageable pageable, String brand, String model, String build) {
    String baseJpql = "from AutoscoutNl m where m.dateRegisted is not null and m.repetition is null";
    if (!StringUtils.isEmpty(brand)) {
        baseJpql += " and m.brand = '" + brand + "'";
    }//  w w  w .  jav a2 s. com
    if (!StringUtils.isEmpty(model)) {
        baseJpql += " and m.model = '" + model + "'";
    }
    if (!StringUtils.isEmpty(build)) {
        baseJpql += " and m.build = '" + build + "'";
    }

    long count = em.createQuery("select count(m) " + baseJpql, Long.class).getSingleResult();

    String jpql = selectSQL + baseJpql;
    log4j.info(jpql);

    List<Object[]> list = em.createQuery(jpql, Object[].class)
            .setFirstResult(pageable.getPageSize() * pageable.getPageNumber())
            .setMaxResults(pageable.getPageSize()).getResultList();
    List<ScoutCar> results = ScoutCar.toScoutCarList(list, true);
    Page<ScoutCar> page = new PageImpl<ScoutCar>(results, pageable, (int) count);
    return page;
}