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

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

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

Introduction

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

Prototype

List<T> getContent();

Source Link

Document

Returns the page content as List .

Usage

From source file:com.github.vanroy.springdata.jest.JestElasticsearchTemplateTests.java

@Test
public void shouldIndexMapWithIndexNameAndTypeAtRuntime() {
    //given/*from w  w  w .j a  v a2 s  .c om*/
    Map<String, Object> person1 = new HashMap<>();
    person1.put("userId", "1");
    person1.put("email", "smhdiu@gmail.com");
    person1.put("title", "Mr");
    person1.put("firstName", "Mohsin");
    person1.put("lastName", "Husen");

    Map<String, Object> person2 = new HashMap<>();
    person2.put("userId", "2");
    person2.put("email", "akonczak@gmail.com");
    person2.put("title", "Mr");
    person2.put("firstName", "Artur");
    person2.put("lastName", "Konczak");

    IndexQuery indexQuery1 = new IndexQuery();
    indexQuery1.setId("1");
    indexQuery1.setObject(person1);
    indexQuery1.setIndexName(INDEX_NAME);
    indexQuery1.setType(TYPE_NAME);

    IndexQuery indexQuery2 = new IndexQuery();
    indexQuery2.setId("2");
    indexQuery2.setObject(person2);
    indexQuery2.setIndexName(INDEX_NAME);
    indexQuery2.setType(TYPE_NAME);

    List<IndexQuery> indexQueries = new ArrayList<>();
    indexQueries.add(indexQuery1);
    indexQueries.add(indexQuery2);

    //when
    elasticsearchTemplate.bulkIndex(indexQueries);
    elasticsearchTemplate.refresh(INDEX_NAME);

    // then
    SearchQuery searchQuery = new NativeSearchQueryBuilder().withIndices(INDEX_NAME).withTypes(TYPE_NAME)
            .withQuery(matchAllQuery()).build();
    Page<Map> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery, Map.class,
            new JestSearchResultMapper() {
                @Override
                public <T> Page<T> mapResults(SearchResult response, Class<T> clazz, Pageable pageable) {
                    List<Map> chunk = new ArrayList<>();
                    for (SearchResult.Hit<JsonObject, Void> searchHit : response.getHits(JsonObject.class)) {
                        if (response.getHits(JsonObject.class).size() <= 0) {
                            return null;
                        }
                        Map<String, Object> person = new HashMap<String, Object>();
                        person.put("userId", searchHit.source.get("userId").getAsString());
                        person.put("email", searchHit.source.get("email").getAsString());
                        person.put("title", searchHit.source.get("title").getAsString());
                        person.put("firstName", searchHit.source.get("firstName").getAsString());
                        person.put("lastName", searchHit.source.get("lastName").getAsString());
                        chunk.add(person);
                    }
                    if (chunk.size() > 0) {
                        return new PageImpl<T>((List<T>) chunk);
                    }
                    return null;
                }
            });
    assertThat(sampleEntities.getTotalElements(), is(equalTo(2L)));
    assertThat(sampleEntities.getContent().get(0).get("userId"), is(person1.get("userId")));
    assertThat(sampleEntities.getContent().get(1).get("userId"), is(person2.get("userId")));
}

From source file:nu.yona.server.analysis.service.ActivityServiceTest.java

@Test
public void getUserDayActivityOverviews_activityPresent_resultsWithActivity() {
    ZonedDateTime today = getDayStartTime(ZonedDateTime.now(userAnonZone));
    ZonedDateTime yesterday = today.minusDays(1);

    // gambling goal was created 2 weeks ago, see above
    // mock some activity on yesterday 20:58-21:00
    DayActivity yesterdayRecordedActivity = DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, yesterday.toLocalDate());
    Activity recordedActivity = Activity.createInstance(userAnonZone,
            yesterday.plusHours(20).plusMinutes(58).toLocalDateTime(),
            yesterday.plusHours(21).plusMinutes(00).toLocalDateTime(), Optional.empty());
    yesterdayRecordedActivity.addActivity(recordedActivity);
    Set<UUID> relevantGoalIds = userAnonEntity.getGoals().stream().map(Goal::getId).collect(Collectors.toSet());
    when(mockDayActivityRepository.findAll(userAnonId, relevantGoalIds, today.minusDays(2).toLocalDate(),
            today.plusDays(1).toLocalDate())).thenReturn(Arrays.asList(yesterdayRecordedActivity));

    Page<DayActivityOverviewDto<DayActivityDto>> dayOverviews = service.getUserDayActivityOverviews(userId,
            new PageRequest(0, 3));

    // assert that the right retrieve from database was done
    verify(mockDayActivityRepository, times(1)).findAll(userAnonId, relevantGoalIds,
            today.minusDays(2).toLocalDate(), today.plusDays(1).toLocalDate());

    // because the gambling goal was added with creation date two weeks ago, there are multiple days, equal to the limit of
    // our page request = 3
    assertThat(dayOverviews.getNumberOfElements(), equalTo(3));

    // get the current day (first item)
    DayActivityOverviewDto<DayActivityDto> dayOverview = dayOverviews.getContent().get(0);
    assertThat(dayOverview.getDayActivities().size(), equalTo(userAnonEntity.getGoals().size()));
    DayActivityDto dayActivityForGambling = dayOverview.getDayActivities().stream()
            .filter(a -> a.getGoalId().equals(gamblingGoal.getId())).findAny().get();
    assertThat(dayActivityForGambling.getStartTime(), equalTo(today));
    assertThat(dayActivityForGambling.getTotalActivityDurationMinutes().get(), equalTo(0));
    assertThat(dayActivityForGambling.getTotalMinutesBeyondGoal(), equalTo(0));

    // get yesterday, with recorded activity
    dayOverview = dayOverviews.getContent().get(1);
    assertThat(dayOverview.getDayActivities().size(), equalTo(1));
    dayActivityForGambling = dayOverview.getDayActivities().stream()
            .filter(a -> a.getGoalId().equals(gamblingGoal.getId())).findAny().get();
    assertThat(dayActivityForGambling.getStartTime(), equalTo(yesterday));
    assertThat(dayActivityForGambling.getTotalActivityDurationMinutes().get(), equalTo(2));
    assertThat(dayActivityForGambling.getTotalMinutesBeyondGoal(), equalTo(2));
}

From source file:nu.yona.server.analysis.service.ActivityServiceTest.java

@Test
public void getUserWeekActivityOverviews_activityPresent_resultsWithActivity() {
    ZonedDateTime today = getDayStartTime(ZonedDateTime.now(userAnonZone));

    // gambling goal was created 2 weeks ago, see above
    // mock some activity in previous week on Saturday 19:10-19:55
    WeekActivity previousWeekRecordedActivity = WeekActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today.minusWeeks(1)).toLocalDate());
    ZonedDateTime saturdayStartOfDay = getWeekStartTime(today).minusDays(1);
    DayActivity previousWeekSaturdayRecordedActivity = DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, saturdayStartOfDay.toLocalDate());
    Activity recordedActivity = Activity.createInstance(userAnonZone,
            saturdayStartOfDay.plusHours(19).plusMinutes(10).toLocalDateTime(),
            saturdayStartOfDay.plusHours(19).plusMinutes(55).toLocalDateTime(), Optional.empty());
    previousWeekSaturdayRecordedActivity.addActivity(recordedActivity);
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(7).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(6).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(5).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(4).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(3).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(DayActivity.createInstance(userAnonEntity, gamblingGoal,
            userAnonZone, getWeekStartTime(today).minusDays(2).toLocalDate()));
    previousWeekRecordedActivity.addDayActivity(previousWeekSaturdayRecordedActivity);

    when(mockWeekActivityRepository.findAll(userAnonId, getWeekStartTime(today.minusWeeks(4)).toLocalDate(),
            getWeekStartTime(today).plusWeeks(1).toLocalDate()))
                    .thenReturn(new HashSet<>(Arrays.asList(previousWeekRecordedActivity)));

    Page<WeekActivityOverviewDto> weekOverviews = service.getUserWeekActivityOverviews(userId,
            new PageRequest(0, 5));

    // assert that the right retrieve from database was done
    verify(mockWeekActivityRepository, times(1)).findAll(userAnonId,
            getWeekStartTime(today.minusWeeks(4)).toLocalDate(),
            getWeekStartTime(today).plusWeeks(1).toLocalDate());

    // because the gambling goal was added with creation date two weeks ago, there are multiple weeks
    assertThat(weekOverviews.getNumberOfElements(), equalTo(3));

    // get the current week (first item)
    WeekActivityOverviewDto weekOverview = weekOverviews.getContent().get(0);
    assertThat(weekOverview.getWeekActivities().size(), equalTo(userAnonEntity.getGoals().size()));
    WeekActivityDto weekActivityForGambling = weekOverview.getWeekActivities().stream()
            .filter(a -> a.getGoalId().equals(gamblingGoal.getId())).findAny().get();
    assertThat(weekActivityForGambling.getStartTime(), equalTo(getWeekStartTime(today)));
    // TODO: mock day activity in this week?
    // int thisWeekNumberOfWeekDaysPast = today.getDayOfWeek() == DayOfWeek.SUNDAY ? 0 : today.getDayOfWeek().getValue();
    // assertThat(weekActivityForGambling.getDayActivities().size(), equalTo(1 + thisWeekNumberOfWeekDaysPast));
    //// always contains Sunday because it is the first day of the week
    // assertThat(weekActivityForGambling.getDayActivities(), hasKey(DayOfWeek.SUNDAY));

    // get the previous week, with recorded activity
    weekOverview = weekOverviews.getContent().get(1);
    assertThat(weekOverview.getWeekActivities().size(), equalTo(1));
    weekActivityForGambling = weekOverview.getWeekActivities().stream()
            .filter(a -> a.getGoalId().equals(gamblingGoal.getId())).findAny().get();
    assertThat(weekActivityForGambling.getStartTime(), equalTo(getWeekStartTime(today.minusWeeks(1))));
    assertThat(weekActivityForGambling.getDayActivities().size(), equalTo(7));
    DayActivityDto previousWeekSaturdayActivity = weekActivityForGambling.getDayActivities()
            .get(DayOfWeek.SATURDAY);
    assertThat(previousWeekSaturdayActivity.getTotalActivityDurationMinutes().get(), equalTo(45));
    assertThat(previousWeekSaturdayActivity.getTotalMinutesBeyondGoal(), equalTo(45));
    DayActivityDto previousWeekFridayActivity = weekActivityForGambling.getDayActivities()
            .get(DayOfWeek.FRIDAY);
    assertThat(previousWeekFridayActivity.getTotalActivityDurationMinutes().get(), equalTo(0));

    // get the week the gambling goal was created
    weekOverview = weekOverviews.getContent().get(2);
    assertThat(weekOverview.getWeekActivities().size(), equalTo(1));
    weekActivityForGambling = weekOverview.getWeekActivities().stream()
            .filter(a -> a.getGoalId().equals(gamblingGoal.getId())).findAny().get();
    assertThat(weekActivityForGambling.getStartTime(), equalTo(getWeekStartTime(today.minusWeeks(2))));
    // TODO: mock day activity in this week?
    // int expectedNumberOfWeekDaysRecorded = gamblingGoal.getCreationTime().getDayOfWeek() == DayOfWeek.SUNDAY ? 7
    // : 7 - gamblingGoal.getCreationTime().getDayOfWeek().getValue();
    // assertThat(weekActivityForGambling.getDayActivities().size(), equalTo(expectedNumberOfWeekDaysRecorded));
    //// always contains Saturday because it is the last day of the week
    // assertThat(weekActivityForGambling.getDayActivities(), hasKey(DayOfWeek.SATURDAY));
}

From source file:org.activiti.app.rest.runtime.AbstractProcessInstancesResource.java

protected Map<String, List<RelatedContent>> groupContentByField(Page<RelatedContent> allContent) {
    HashMap<String, List<RelatedContent>> result = new HashMap<String, List<RelatedContent>>();
    List<RelatedContent> list;
    for (RelatedContent content : allContent.getContent()) {
        list = result.get(content.getField());
        if (list == null) {
            list = new ArrayList<RelatedContent>();
            result.put(content.getField(), list);
        }/*from  ww w  . j a va  2 s. co  m*/
        list.add(content);
    }
    return result;
}

From source file:org.apache.shiro.web.session.mgt.OnlineWebSessionManager.java

/**
 * ?session? session/*from w  w w.  j ava2s .  c om*/
 */
@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<String> 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:org.apereo.openlrs.model.event.EventConversionService.java

public Page<Event> toEventPage(Page<OpenLRSEntity> page) {
    Page<Event> events = null;
    if (page != null && page.getContent() != null && !page.getContent().isEmpty()) {
        List<OpenLRSEntity> entities = page.getContent();
        List<Event> eventList = new ArrayList<Event>();
        for (OpenLRSEntity entity : entities) {
            eventList.add(toEvent(entity));
        }/*from   ww  w.ja v a  2  s  . c o  m*/

        events = new PageImpl<Event>(eventList);
    }

    return events;
}

From source file:org.apereo.openlrs.model.event.EventConversionService.java

public Page<Statement> toXApiPage(Page<OpenLRSEntity> page) {
    Page<Statement> statements = null;
    if (page != null && page.getContent() != null && !page.getContent().isEmpty()) {
        List<OpenLRSEntity> entities = page.getContent();
        List<Statement> statementList = new ArrayList<Statement>();
        for (OpenLRSEntity entity : entities) {
            statementList.add(toXApi(entity));
        }//from www.j a  v  a  2 s.  c  o m

        statements = new PageImpl<Statement>(statementList);
    }

    return statements;
}

From source file:org.duracloud.durastore.rest.BitIntegrityReportRest.java

private Response getReport(String spaceId, String storeId, boolean headOnly) {
    String account = getSubdomain();

    log.info("getting bit integrity report log for account:{}, storeId:{}, spaceId:{}",
            new Object[] { account, storeId, spaceId });

    if (StringUtils.isBlank(storeId)) {
        for (StorageAccount storageAccount : this.storageProviderFactory.getStorageAccounts()) {
            if (storageAccount.isPrimary()) {
                storeId = storageAccount.getId();
                break;
            }//from  ww w.ja  v  a2  s .c o  m
        }

        if (StringUtils.isBlank(storeId)) {
            throw new DuraCloudRuntimeException(
                    "storeId is blank and no primary storage account is indicated.");
        }
    }

    try {
        PageRequest pageRequest = new PageRequest(0, 1);
        Page<BitIntegrityReport> page = repo
                .findByStoreIdAndSpaceIdAndDisplayTrueOrderByCompletionDateDesc(storeId, spaceId, pageRequest);

        if (page == null || CollectionUtils.isEmpty(page.getContent())) {
            StorageProvider storage = storageProviderFactory.getStorageProvider(storeId);
            try { // Determine if space exists in order to return the right error
                storage.getSpaceACLs(spaceId);
            } catch (NotFoundException e) {
                return responseNotFound("Space with ID " + spaceId + " does not exist");
            }
            return responseBad("No reports matching the criteria found.", Response.Status.NO_CONTENT);
        }

        BitIntegrityReport report = page.getContent().get(0);
        //retrieve report info from primary store.
        StorageProvider provider = this.storageProviderFactory.getStorageProvider();
        String reportSpaceId = report.getReportSpaceId();
        String reportContentId = report.getReportContentId();
        Map<String, String> props = provider.getContentProperties(reportSpaceId, reportContentId);
        String contentLength = props.get(StorageProvider.PROPERTIES_CONTENT_SIZE);

        ResponseBuilder responseBuilder;

        if (headOnly) {
            responseBuilder = Response.ok();
        } else {
            InputStream is = provider.getContent(reportSpaceId, reportContentId).getContentStream();
            responseBuilder = Response.ok(is);
        }

        responseBuilder.header(HttpHeaders.BIT_INTEGRITY_REPORT_RESULT, report.getResult().name());
        responseBuilder.header(HttpHeaders.BIT_INTEGRITY_REPORT_COMPLETION_DATE,
                DateUtil.convertToString(report.getCompletionDate().getTime()));
        responseBuilder.header(HttpHeaders.CONTENT_LENGTH, contentLength);

        return responseBuilder.build();

    } catch (Exception e) {
        log.error(MessageFormat.format("Error for  account:{0}, storeId:{1}, spaceId:{2} -> {3}", account,
                storeId, spaceId, e.getMessage()));
        return responseBad(e);
    }
}

From source file:org.eclipse.hawkbit.repository.jpa.JpaRolloutManagement.java

private Long createActionsForTargetsInNewTransaction(final long rolloutId, final long groupId,
        final int limit) {
    return runInNewTransaction("createActionsForTargets", status -> {
        final PageRequest pageRequest = new PageRequest(0, limit);
        final Rollout rollout = rolloutRepository.findOne(rolloutId);
        final RolloutGroup group = rolloutGroupRepository.findOne(groupId);

        final DistributionSet distributionSet = rollout.getDistributionSet();
        final ActionType actionType = rollout.getActionType();
        final long forceTime = rollout.getForcedTime();

        final Page<Target> targets = targetManagement.findAllTargetsInRolloutGroupWithoutAction(pageRequest,
                groupId);// www. j  av  a  2 s.  c  o m
        if (targets.getTotalElements() > 0) {
            createScheduledAction(targets.getContent(), distributionSet, actionType, forceTime, rollout, group);
        }

        return Long.valueOf(targets.getNumberOfElements());
    });
}