Example usage for org.springframework.data.domain Page hasContent

List of usage examples for org.springframework.data.domain Page hasContent

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.domain.*
  5. Page
  6. hasContent

Introduction

In this page you can find the example usage for org.springframework.data.domain Page hasContent.

Prototype

boolean hasContent();

Source Link

Document

Returns whether the Slice has content at all.

Usage

From source file:org.jtalks.jcommune.model.dao.search.hibernate.TopicHibernateSearchDaoTest.java

@Test(dataProvider = "parameterSearchByRoot")
public void testSearchByRoot(String word, String wordWithSameRoot) {
    Topic expectedTopic = PersistedObjectsFactory.getDefaultTopic();
    expectedTopic.setTitle(word);/*w  w  w  .ja v  a  2 s.c o  m*/

    saveAndFlushIndexes(Arrays.asList(expectedTopic));
    configureMocks(wordWithSameRoot, wordWithSameRoot);

    Page<Topic> searchResultPage = topicSearchDao.searchByTitleAndContent(wordWithSameRoot,
            DEFAULT_PAGE_REQUEST, Arrays.asList(expectedTopic.getBranch().getId()));
    Assert.assertTrue(searchResultPage.hasContent(), "Search result must not be empty.");
}

From source file:org.jtalks.jcommune.model.dao.search.hibernate.TopicHibernateSearchDaoTest.java

@Test(dataProvider = "parameterSearchByBbCodes")
public void testSearchByBbCodes(String content, String bbCode) {
    Topic expectedTopic = PersistedObjectsFactory.getDefaultTopic();
    expectedTopic.getLastPost().setPostContent(content);

    saveAndFlushIndexes(Arrays.asList(expectedTopic));
    configureMocks(bbCode, bbCode);/*from   w w  w .  jav  a2s .c om*/

    Page<Topic> searchResultPage = topicSearchDao.searchByTitleAndContent(bbCode, DEFAULT_PAGE_REQUEST,
            Arrays.asList(expectedTopic.getBranch().getId()));
    Assert.assertTrue(!searchResultPage.hasContent(), "Search result must be empty.");
}

From source file:org.jtalks.jcommune.model.dao.search.hibernate.TopicHibernateSearchDaoTest.java

@Test(dataProvider = "parameterSearchByBbCodesContent")
public void testSearchByBbCodesContent(String content, String bbCodeContent) {
    Topic expectedTopic = PersistedObjectsFactory.getDefaultTopic();
    expectedTopic.getLastPost().setPostContent(content);

    saveAndFlushIndexes(Arrays.asList(expectedTopic));
    configureMocks(bbCodeContent, bbCodeContent);

    Page<Topic> searchResultPage = topicSearchDao.searchByTitleAndContent(bbCodeContent, DEFAULT_PAGE_REQUEST,
            Arrays.asList(expectedTopic.getBranch().getId()));
    Assert.assertTrue(searchResultPage.hasContent(), "Search result must not be empty.");
}

From source file:org.jtalks.jcommune.service.transactional.TransactionalTopicFetchServiceTest.java

@Test(dataProvider = "parameterSearchPostsWithEmptySearchPhrase")
public void testSearchPostsWithEmptySearchPhrase(String phrase) {
    Page<Topic> searchResultPage = topicFetchService.searchByTitleAndContent(phrase, "50");

    Assert.assertTrue(!searchResultPage.hasContent(), "The search result must be empty.");
}

From source file:org.lazulite.boot.autoconfigure.osaam.shiro.web.session.mgt.OnlineWebSessionManager.java

/**
 * ?session? session/* w  ww .  j  a  v  a  2 s.co  m*/
 */
@Override
public void validateSessions() {
    if (log.isInfoEnabled()) {
        log.info("invalidation sessions...");
    }

    int invalidCount = 0;

    int timeout = (int) getGlobalSessionTimeout();
    Date expiredDate = DateUtils.addMilliseconds(new Date(), 0 - timeout);
    PageRequest pageRequest = new PageRequest(0, 100);
    Page<UserOnline> page = userOnlineService.findExpiredUserOnlineList(expiredDate, pageRequest);

    //??
    while (page.hasContent()) {
        List<Long> needOfflineIdList = Lists.newArrayList();
        for (UserOnline userOnline : page.getContent()) {
            try {
                SessionKey key = new DefaultSessionKey(userOnline.getId());
                Session session = retrieveSession(key);
                //cache db
                if (session != null) {
                    session.setAttribute(ShiroConstants.ONLY_CLEAR_CACHE, true);
                }
                validate(session, key);
            } catch (InvalidSessionException e) {
                if (log.isDebugEnabled()) {
                    boolean expired = (e instanceof ExpiredSessionException);
                    String msg = "Invalidated session with id [" + userOnline.getId() + "]"
                            + (expired ? " (expired)" : " (stopped)");
                    log.debug(msg);
                }
                invalidCount++;
                needOfflineIdList.add(userOnline.getId());
            }

        }
        if (needOfflineIdList.size() > 0) {
            try {
                userOnlineService.batchOffline(needOfflineIdList);
            } catch (Exception e) {
                log.error("batch delete db session error.", e);
            }
        }
        pageRequest = new PageRequest(0, pageRequest.getPageSize());
        page = userOnlineService.findExpiredUserOnlineList(expiredDate, pageRequest);
    }

    if (log.isInfoEnabled()) {
        String msg = "Finished invalidation session.";
        if (invalidCount > 0) {
            msg += "  [" + invalidCount + "] sessions were stopped.";
        } else {
            msg += "  No sessions were stopped.";
        }
        log.info(msg);
    }

}

From source file:piecework.export.concrete.ExportAsCommaSeparatedValuesProvider.java

@Override
public List<String> next() {
    Page<ProcessInstance> page = pager.nextPage();

    List<String> rows = page.hasContent() ? new ArrayList<String>(page.getNumberOfElements())
            : Collections.<String>emptyList();

    if (page.hasContent()) {
        List<ProcessInstance> instances = page.getContent();
        for (ProcessInstance instance : instances) {
            String row = convert(instance);
            if (row != null)
                rows.add(row);//  w w  w . ja  va2 s. co  m
        }
    }

    return rows;
}

From source file:piecework.export.concrete.ExportAsExcelWorkbookProvider.java

@Override
public List<Row> next() {
    Page<ProcessInstance> page = pager.nextPage();

    List<Row> rows = page.hasContent() ? new ArrayList<Row>(page.getNumberOfElements())
            : Collections.<Row>emptyList();

    if (page.hasContent()) {
        List<ProcessInstance> instances = page.getContent();
        for (ProcessInstance instance : instances) {
            rows.add(convert(instance));
        }/*from   w w  w  .  j  a va 2s  . c  om*/
    }

    return rows;
}

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. j a v a2s . c  om
        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.service.ProcessInstanceService.java

public SearchResults search(MultivaluedMap<String, String> rawQueryParameters, Entity principal)
        throws StatusCodeError {
    Set<String> processDefinitionKeys = principal.getProcessDefinitionKeys(AuthorizationRole.OVERSEER);
    Set<Process> allowedProcesses = processService.findProcesses(processDefinitionKeys);

    SearchCriteria.Builder executionCriteriaBuilder = new SearchCriteria.Builder(rawQueryParameters,
            allowedProcesses, FacetFactory.facetMap(allowedProcesses), sanitizer);

    ViewContext context = new ViewContext(settings, VERSION);

    SearchResults.Builder resultsBuilder = new SearchResults.Builder().resourceLabel("Workflows")
            .resourceName(ProcessInstance.Constants.ROOT_ELEMENT_NAME).link(context.getApplicationUri());

    if (!allowedProcesses.isEmpty()) {
        for (Process allowedProcess : allowedProcesses) {
            String allowedProcessDefinitionKey = allowedProcess.getProcessDefinitionKey();

            if (allowedProcessDefinitionKey != null) {
                executionCriteriaBuilder.processDefinitionKey(allowedProcessDefinitionKey);
                resultsBuilder.definition(
                        new Process.Builder(allowedProcess, new PassthroughSanitizer()).build(context));
            }/*from ww  w.ja  va2 s .  c om*/
        }
        SearchCriteria searchCriteria = executionCriteriaBuilder.build();

        if (searchCriteria.getSanitizedParameters() != null) {
            for (Map.Entry<String, List<String>> entry : searchCriteria.getSanitizedParameters().entrySet()) {
                resultsBuilder.parameter(entry.getKey(), entry.getValue());
            }
        }

        Pageable pageable = SearchUtility.pageable(searchCriteria, sanitizer);
        Page<ProcessInstance> page = processInstanceRepository.findByCriteria(processDefinitionKeys,
                searchCriteria, pageable, sanitizer);

        if (page.hasContent()) {
            for (ProcessInstance instance : page.getContent()) {
                resultsBuilder.item(new ProcessInstance.Builder(instance).build(context));
            }
        }

        resultsBuilder.page(page, pageable);
    }
    return resultsBuilder.build();
}

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//from   w  ww  .  j a va  2  s  .c  o  m
        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);
}