Java 类org.springframework.data.domain.Slice 实例源码

@Test
public void useSliceToLoadContent() {

    repository.deleteAll();

    // int repository with some values that can be ordered
    int totalNumberUsers = 11;
    List<User> source = new ArrayList<User>(totalNumberUsers);

    for (int i = 1; i <= totalNumberUsers; i++) {

        User user = new User();
        user.setLastname(this.user.getLastname());
        user.setUsername(user.getLastname() + "-" + String.format("%03d", i));
        source.add(user);
    }

    repository.save(source);

    Slice<User> users = repository.findByLastnameOrderByUsernameAsc(this.user.getLastname(), new PageRequest(1, 5));

    assertThat(users, contains(source.subList(5, 10).toArray()));
}

@RequestMapping(value = "/", method = GET)
public String home(Model model) {
    String springVersion = webUI.parameterizedMessage("home.spring.version", SpringBootVersion.getVersion());
    model.addAttribute("springVersion", springVersion);

    GitHubStats gitHubStats = webUI.getCurrentGitHubStats();
    if (gitHubStats != null) {
        model.addAttribute("showGitHubStats", true);
        model.addAttribute("gitHubStats", gitHubStats);
    }

    if (webUI.isNixMash()) {
        SiteImage siteImage = siteService.getHomeBanner();
        model.addAttribute("siteImage", siteImage);
    }

    Slice<Post> posts = postService.getPublishedPosts(0, 10);
    if (posts.getContent().size() > 0)
        model.addAttribute("posts", posts);

    return HOME_VIEW;
}

@RequestMapping(value = "/quicksearch/page/{pageNumber}",
        produces = "text/html;charset=UTF-8")
public String getQuickSearchPosts(@PathVariable int pageNumber,
                                  HttpServletRequest request,
                                  CurrentUser currentUser) {
    String search = (String) WebUtils.getSessionAttribute(request, SESSION_QUICKSEARCH_QUERY);
    String result;
    List<PostDoc> postDocs = postDocService.doQuickSearch(search);
    if (postDocs.size() == 0) {
        result = fmService.getNoResultsMessage(search);
    } else {
        Slice<PostDoc> posts = postDocService.doPagedQuickSearch(search, pageNumber, POST_PAGING_SIZE);
        result = populatePostDocStream(posts.getContent(), currentUser);
        WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_QUICKSEARCH_POSTS, posts.getContent());
    }
    return result;
}

@Transactional(readOnly = true)
public Slice<ListAnnouncementDTO> list(final ListAnnouncementRequest request, final Pageable pageRequest) {
    final ListAnnouncementFilter filter = new ListAnnouncementFilter(occupationRepository);

    if (!activeUserService.isModeratorOrAdmin()) {
        filter.withSubscriberPerson(activeUserService.requireActivePerson());
    }

    final Optional<Organisation> maybeOrganisation = resolveOrganisation(request);

    switch (request.getDirection()) {
        case SENT:
            maybeOrganisation.ifPresent(filter::withFromOrganisation);
            break;
        case RECEIVED:
            maybeOrganisation.ifPresent(filter::withSubscriberOrganisation);
            break;
        default:
            throw new IllegalArgumentException("Invalid direction");
    }

    return filter.buildPredicate()
            .map(predicate -> announcementRepository.findAllAsSlice(predicate, pageRequest))
            .map(slice -> transform(pageRequest, slice))
            .orElseGet(() -> new SliceImpl<>(emptyList()));
}

private void deleteScheduledActions(final JpaRollout rollout, final Slice<JpaAction> scheduledActions) {
    final boolean hasScheduledActions = scheduledActions.getNumberOfElements() > 0;

    if (hasScheduledActions) {
        try {
            final Iterable<JpaAction> iterable = scheduledActions::iterator;
            final List<Long> actionIds = StreamSupport.stream(iterable.spliterator(), false).map(Action::getId)
                    .collect(Collectors.toList());
            actionRepository.deleteByIdIn(actionIds);
            afterCommit.afterCommit(() -> eventPublisher.publishEvent(
                    new RolloutUpdatedEvent(rollout, EventPublisherHolder.getInstance().getApplicationId())));
        } catch (final RuntimeException e) {
            LOGGER.error("Exception during deletion of actions of rollout {}", rollout, e);
        }
    }
}

@Override
public Slice<SoftwareModule> findAll(final Pageable pageable) {

    final List<Specification<JpaSoftwareModule>> specList = new ArrayList<>(2);

    Specification<JpaSoftwareModule> spec = SoftwareModuleSpecification.isDeletedFalse();
    specList.add(spec);

    spec = (root, query, cb) -> {
        if (!query.getResultType().isAssignableFrom(Long.class)) {
            root.fetch(JpaSoftwareModule_.type);
        }
        return cb.conjunction();
    };

    specList.add(spec);

    return convertSmPage(findByCriteriaAPI(pageable, specList), pageable);
}

@Test
@Description("Test verifies that action-states of an action are found by using id-based search.")
public void findActionStatusByActionId() {
    final DistributionSet testDs = testdataFactory.createDistributionSet("TestDs", "1.0",
            new ArrayList<DistributionSetTag>());
    final List<Target> testTarget = testdataFactory.createTargets(1);
    // one action with one action status is generated
    final Long actionId = assignDistributionSet(testDs, testTarget).getActions().get(0);
    final Slice<Action> actions = deploymentManagement.findActionsByTarget(testTarget.get(0).getControllerId(),
            PAGE);
    final ActionStatus expectedActionStatus = ((JpaAction) actions.getContent().get(0)).getActionStatus().get(0);

    // act
    final Page<ActionStatus> actionStates = deploymentManagement.findActionStatusByAction(PAGE, actionId);

    assertThat(actionStates.getContent()).hasSize(1);
    assertThat(actionStates.getContent().get(0)).as("Action-status of action").isEqualTo(expectedActionStatus);
}

/**
 * @param set
 *            the expected distribution set
 * @param targets
 *            the targets that should have it
 */
@Step
private void verifyThatTargetsHaveDistributionSetAssignment(final DistributionSet set, final List<Target> targets,
        final int count) {
    final List<Long> targetIds = targets.stream().map(Target::getId).collect(Collectors.toList());

    final Slice<Target> targetsAll = targetManagement.findAll(PAGE);
    assertThat(targetsAll).as("Count of targets").hasSize(count);

    for (final Target target : targetsAll) {
        if (targetIds.contains(target.getId())) {
            assertThat(deploymentManagement.getAssignedDistributionSet(target.getControllerId()).get())
                    .as("assigned DS").isEqualTo(set);
        }
    }

}

@Test
@Description(value = "Ensures that multiple targets with same controller-ID can be created for different tenants.")
public void createMultipleTargetsWithSameIdForDifferentTenant() throws Exception {
    // known controller ID for overall tenants same
    final String knownControllerId = "controllerId";

    // known tenant names
    final String tenant = "aTenant";
    final String anotherTenant = "anotherTenant";
    // create targets
    createTargetForTenant(knownControllerId, tenant);
    createTargetForTenant(knownControllerId, anotherTenant);

    // ensure both tenants see their target
    final Slice<Target> findTargetsForTenant = findTargetsForTenant(tenant);
    assertThat(findTargetsForTenant).hasSize(1);
    assertThat(findTargetsForTenant.getContent().get(0).getTenant().toUpperCase()).isEqualTo(tenant.toUpperCase());
    final Slice<Target> findTargetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(findTargetsForAnotherTenant).hasSize(1);
    assertThat(findTargetsForAnotherTenant.getContent().get(0).getTenant().toUpperCase())
            .isEqualTo(anotherTenant.toUpperCase());

}

@Test
@Description(value = "Ensures that targtes created by a tenant are not visible by another tenant.")
@WithUser(tenantId = "mytenant", allSpPermissions = true)
public void queryTargetFromDifferentTenantIsNotVisible() throws Exception {
    // create target for another tenant
    final String anotherTenant = "anotherTenant";
    final String controllerAnotherTenant = "anotherController";
    createTargetForTenant(controllerAnotherTenant, anotherTenant);

    // find all targets for current tenant "mytenant"
    final Slice<Target> findTargetsAll = targetManagement.findAll(PAGE);
    // no target has been created for "mytenant"
    assertThat(findTargetsAll).hasSize(0);

    // find all targets for anotherTenant
    final Slice<Target> findTargetsForTenant = findTargetsForTenant(anotherTenant);
    // another tenant should have targets
    assertThat(findTargetsForTenant).hasSize(1);
}

@Test
@Description(value = "Ensures that targets created from a different tenant cannot be deleted from other tenants")
@WithUser(tenantId = "mytenant", allSpPermissions = true)
public void deleteTargetFromOtherTenantIsNotPossible() throws Exception {
    // create target for another tenant
    final String anotherTenant = "anotherTenant";
    final String controllerAnotherTenant = "anotherController";
    final Target createTargetForTenant = createTargetForTenant(controllerAnotherTenant, anotherTenant);

    // ensure target cannot be deleted by 'mytenant'
    try {
        targetManagement.delete(Arrays.asList(createTargetForTenant.getId()));
        fail("mytenant should not have been able to delete target of anotherTenant");
    } catch (final EntityNotFoundException ex) {
        // ok
    }

    Slice<Target> targetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(targetsForAnotherTenant).hasSize(1);

    // ensure another tenant can delete the target
    deleteTargetsForTenant(anotherTenant, Arrays.asList(createTargetForTenant.getId()));
    targetsForAnotherTenant = findTargetsForTenant(anotherTenant);
    assertThat(targetsForAnotherTenant).hasSize(0);
}

@Override
protected List<ProxyTag> loadBeans(final int startIndex, final int count) {
    final Slice<DistributionSetTag> dsTagBeans = getTagManagement()
            .findAll(new OffsetBasedPageRequest(startIndex, count, sort));

    return dsTagBeans.getContent().stream().map(tag -> {
        final ProxyTag proxyTargetTag = new ProxyTag();
        proxyTargetTag.setColour(tag.getColour());
        proxyTargetTag.setDescription(tag.getDescription());
        proxyTargetTag.setName(tag.getName());
        proxyTargetTag.setId(tag.getId());
        final TagIdName tagIdName = new TagIdName(tag.getName(), tag.getId());
        proxyTargetTag.setTagIdName(tagIdName);

        return proxyTargetTag;

    }).collect(Collectors.toList());
}

/**
 * Creates a list of {@link ProxyAction}s for presentation layer from slice
 * of {@link Action}s.
 *
 * @param actionBeans
 *            slice of {@link Action}s
 * @return list of {@link ProxyAction}s
 */
private static List<ProxyAction> createProxyActions(final Slice<Action> actionBeans) {
    final List<ProxyAction> proxyActions = new ArrayList<>();
    for (final Action action : actionBeans) {
        final ProxyAction proxyAction = new ProxyAction();
        final String dsNameVersion = action.getDistributionSet().getName() + ":"
                + action.getDistributionSet().getVersion();
        proxyAction.setActive(action.isActive());
        proxyAction.setIsActiveDecoration(buildIsActiveDecoration(action));
        proxyAction.setDsNameVersion(dsNameVersion);
        proxyAction.setAction(action);
        proxyAction.setId(action.getId());
        proxyAction.setLastModifiedAt(action.getLastModifiedAt());
        proxyAction.setRolloutName(action.getRollout() != null ? action.getRollout().getName() : "");
        proxyAction.setStatus(action.getStatus());

        proxyActions.add(proxyAction);
    }
    return proxyActions;
}

@Override
public ResponseEntity<PagedList<MgmtDistributionSetType>> getDistributionSetTypes(
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {

    final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
    final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
    final Sort sorting = PagingUtility.sanitizeDistributionSetTypeSortParam(sortParam);
    final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);

    final Slice<DistributionSetType> findModuleTypessAll;
    long countModulesAll;
    if (rsqlParam != null) {
        findModuleTypessAll = distributionSetTypeManagement.findByRsql(pageable, rsqlParam);
        countModulesAll = ((Page<DistributionSetType>) findModuleTypessAll).getTotalElements();
    } else {
        findModuleTypessAll = distributionSetTypeManagement.findAll(pageable);
        countModulesAll = distributionSetTypeManagement.count();
    }

    final List<MgmtDistributionSetType> rest = MgmtDistributionSetTypeMapper
            .toListResponse(findModuleTypessAll.getContent());
    return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
}

@Override
public ResponseEntity<PagedList<MgmtSoftwareModule>> getSoftwareModules(
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {

    final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
    final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
    final Sort sorting = PagingUtility.sanitizeSoftwareModuleSortParam(sortParam);

    final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);

    final Slice<SoftwareModule> findModulesAll;
    long countModulesAll;
    if (rsqlParam != null) {
        findModulesAll = softwareModuleManagement.findByRsql(pageable, rsqlParam);
        countModulesAll = ((Page<SoftwareModule>) findModulesAll).getTotalElements();
    } else {
        findModulesAll = softwareModuleManagement.findAll(pageable);
        countModulesAll = softwareModuleManagement.count();
    }

    final List<MgmtSoftwareModule> rest = MgmtSoftwareModuleMapper.toResponse(findModulesAll.getContent());
    return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
}

@Override
public ResponseEntity<PagedList<MgmtDistributionSet>> getDistributionSets(
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_OFFSET, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_OFFSET) final int pagingOffsetParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_PAGING_LIMIT, defaultValue = MgmtRestConstants.REQUEST_PARAMETER_PAGING_DEFAULT_LIMIT) final int pagingLimitParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SORTING, required = false) final String sortParam,
        @RequestParam(value = MgmtRestConstants.REQUEST_PARAMETER_SEARCH, required = false) final String rsqlParam) {

    final int sanitizedOffsetParam = PagingUtility.sanitizeOffsetParam(pagingOffsetParam);
    final int sanitizedLimitParam = PagingUtility.sanitizePageLimitParam(pagingLimitParam);
    final Sort sorting = PagingUtility.sanitizeDistributionSetSortParam(sortParam);

    final Pageable pageable = new OffsetBasedPageRequest(sanitizedOffsetParam, sanitizedLimitParam, sorting);
    final Slice<DistributionSet> findDsPage;
    final long countModulesAll;
    if (rsqlParam != null) {
        findDsPage = distributionSetManagement.findByRsql(pageable, rsqlParam);
        countModulesAll = ((Page<DistributionSet>) findDsPage).getTotalElements();
    } else {
        findDsPage = distributionSetManagement.findAll(pageable);
        countModulesAll = distributionSetManagement.count();
    }

    final List<MgmtDistributionSet> rest = MgmtDistributionSetMapper.toResponseFromDsList(findDsPage.getContent());
    return ResponseEntity.ok(new PagedList<>(rest, countModulesAll));
}

@Test
@Description("Ensures that a post request for creating one target within a list works.")
public void createTargetsSingleEntryListReturnsSuccessful() throws Exception {
    final String knownName = "someName";
    final String knownControllerId = "controllerId1";
    final String knownDescription = "someDescription";
    final String createTargetsJson = getCreateTargetsListJsonString(knownControllerId, knownName, knownDescription);

    mvc.perform(post(MgmtRestConstants.TARGET_V1_REQUEST_MAPPING).content(createTargetsJson)
            .contentType(MediaType.APPLICATION_JSON)).andDo(MockMvcResultPrinter.print())
            .andExpect(status().is2xxSuccessful());

    final Slice<Target> findTargetsAll = targetManagement.findAll(new PageRequest(0, 100));
    final Target target = findTargetsAll.getContent().get(0);
    assertThat(targetManagement.count()).isEqualTo(1);
    assertThat(target.getControllerId()).isEqualTo(knownControllerId);
    assertThat(target.getName()).isEqualTo(knownName);
    assertThat(target.getDescription()).isEqualTo(knownDescription);
}

@Override
@RequestMapping(value = { "/", "/index" }, method = RequestMethod.GET)
public String index(@RequestParam(value = "page", required = false) Integer currentPage,
        @RequestParam(value = "startsWith", required = false) Character startsWith, Model model,
        HttpServletRequest request) {
    currentPage = getCurrentPage(currentPage, startsWith);

    Long bindingId = getLongParam(request, REQUEST_PARAM_BINDING);
    Predicate filter = null;
    if (bindingId != null) {
        filter = QAlbum.album.binding.id.eq(bindingId);
    }

    Slice<Album> entities = service.findPaginated(currentPage, filter);

    model.addAttribute("albumList", entities);

    return "albums/index";
}

@Test
public void findAllWithPaging() {
    Slice<Post> posts = postService.getPosts(0, 3);
    assertEquals(posts.getSize(), 3);
    ZonedDateTime firstPostDate = posts.getContent().get(0).getPostDate();
    ZonedDateTime secondPostDate = posts.getContent().get(1).getPostDate();

    // firstPostDate is higher (more recent) than secondPostDate with [sort: postDate: DESC]
    assertTrue(firstPostDate.compareTo(secondPostDate) > 0);
}

@Test
public void findPostsByTagId() {
    Slice<Post> posts = postService.getPublishedPostsByTagId(1, 0, 3);

    // posts are retrieved for tagId #1 as all 5 H2 posts have tagId #1
    assertEquals(posts.getSize(), 3);
}

@RequestMapping(value = "/dev/banner", method = GET)
public String homeBannerDisplay(Model model, @RequestParam(value = "id") long siteImageId) {
    String springVersion = webUI.parameterizedMessage("home.spring.version", SpringBootVersion.getVersion());
    model.addAttribute("springVersion", springVersion);
        SiteImage siteImage = siteService.getHomeBanner(siteImageId);
        model.addAttribute("siteImage", siteImage);

    Slice<Post> posts = postService.getPublishedPosts(0, 10);
    if (posts.getContent().size() > 0)
        model.addAttribute("posts", posts);

    return HOME_VIEW;
}

@RequestMapping(value = "/titles/page/{pageNumber}", produces = "text/html;charset=UTF-8")
    public String getPostTitles(@PathVariable Integer pageNumber, HttpServletRequest request, CurrentUser currentUser) {
//        Slice<Post> posts = postService.getPublishedPosts(pageNumber, TITLE_PAGING_SIZE);
        Slice<Post> posts = postService.getPagedPostsByPostType(PostType.POST, pageNumber, TITLE_PAGING_SIZE);
        String result = populatePostStream(posts.getContent(), currentUser, TITLE_TEMPLATE);
        WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_POSTTITLES, posts.getContent());
        return result;
    }

@RequestMapping(value = "/links/page/{pageNumber}", produces = "text/html;charset=UTF-8")
public String getLinks(@PathVariable Integer pageNumber, HttpServletRequest request, CurrentUser currentUser) {
    Slice<Post> posts = postService.getPagedPostsByPostType(PostType.LINK, pageNumber, POST_PAGING_SIZE);
    String result;
    if (applicationSettings.getTitleStreamDisplay())
        result = populatePostStream(posts.getContent(), currentUser, TITLE_TEMPLATE);
    else
        result = populatePostStream(posts.getContent(), currentUser);
    if (StringUtils.isEmpty(result)) {
        result = fmService.getNoLinksMessage();
    }
    WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_JUSTLINKS, posts.getContent());
    return result;
}

@RequestMapping(value = "/titles/tag/{tagid}/page/{pageNumber}",
        produces = "text/html;charset=UTF-8")
public String getPostTitlesByTagId(@PathVariable long tagid,
                                   @PathVariable int pageNumber,
                                   HttpServletRequest request,
                                   CurrentUser currentUser) {
    Slice<Post> posts = postService.getPublishedPostsByTagId(tagid, pageNumber, TITLE_PAGING_SIZE);
    String result = populatePostStream(posts.getContent(), currentUser, TITLE_TEMPLATE);
    WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_TAGPOSTTITLES, posts.getContent());
    return result;
}

@RequestMapping(value = "/page/{pageNumber}", produces = "text/html;charset=UTF-8")
    public String getPosts(@PathVariable Integer pageNumber, HttpServletRequest request, CurrentUser currentUser) {
//        Slice<Post> posts = postService.getPublishedPosts(pageNumber, POST_PAGING_SIZE);
        boolean titleDisplay = applicationSettings.getTitleStreamDisplay();
        int pagingSize = titleDisplay ? TITLE_PAGING_SIZE : POST_PAGING_SIZE;
        Slice<Post> posts = postService.getPagedPostsByPostType(PostType.POST, pageNumber, TITLE_PAGING_SIZE);
        String template = titleDisplay ? "title" : null;
        String result = populatePostStream(posts.getContent(), currentUser, template);
        WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_POSTS, posts.getContent());
        return result;
    }

@RequestMapping(value = "/tag/{tagid}/page/{pageNumber}",
        produces = "text/html;charset=UTF-8")
public String getPostsByTagId(@PathVariable long tagid,
                              @PathVariable int pageNumber,
                              HttpServletRequest request,
                              CurrentUser currentUser) {
    String template = applicationSettings.getTitleStreamDisplay() ? "title" : null;
    Slice<Post> posts = postService.getPublishedPostsByTagId(tagid, pageNumber, POST_PAGING_SIZE);
    String result = populatePostStream(posts.getContent(), currentUser, template);
    WebUtils.setSessionAttribute(request, SESSION_ATTRIBUTE_TAGGEDPOSTS, posts.getContent());
    return result;
}

@RequestMapping(value = "/search/page/{pageNumber}",
        produces = "text/html;charset=UTF-8")
public String getFullSearchPosts(@PathVariable int pageNumber,
                                 HttpServletRequest request,
                                 CurrentUser currentUser) {
    PostQueryDTO postQueryDTO =
            (PostQueryDTO) WebUtils.getSessionAttribute(request, SESSION_POSTQUERYDTO);
    String result = null;
    List<PostDoc> postDocs = null;
    if (postQueryDTO != null) {
        try {
            postDocs = postDocService.doFullSearch(postQueryDTO);
        } catch (UncategorizedSolrException ex) {
            logger.info(MessageFormat.format("Bad Query: {0}", postQueryDTO.getQuery()));
            return fmService.getNoResultsMessage(postQueryDTO.getQuery());
        }

        if (postDocs.size() == 0) {
            result = fmService.getNoResultsMessage(postQueryDTO.getQuery());
        } else {
            Slice<PostDoc> postDocSlice =
                    postDocService.doPagedFullSearch(postQueryDTO, pageNumber, POST_PAGING_SIZE);
            result = populatePostDocStream(postDocSlice.getContent(), currentUser);
            WebUtils.setSessionAttribute(request,
                    SESSION_ATTRIBUTE_FULLSEARCH_POSTS, postDocSlice.getContent());
        }
    }
    return result;
}

@Override
public <T> Slice<T> findSlice(Query<T> query) {
    List<T> list = findAllInternal(query);
    Pageable pageable = query.getPageable();
    if (pageable != null) {
        boolean hasNext = ((pageable.getPageNumber() + 1) * pageable.getPageSize() < total(query));
        return new SliceImpl<T>(list, query.getPageable(), hasNext);
    } else {
        return new SliceImpl<T>(list);
    }
}

@Test
public void executesQueryToSlice() {

    Slice<User> slice = userRepository.findSliceByLastname("Matthews", new PageRequest(0, 1, ASC, "firstname"));

    assertThat(slice.getContent(), hasItem(dave));
    assertThat(slice.hasNext(), is(true));
}

@Override
public Slice<T> findAllAsSlice(final Predicate predicate, final Pageable page) {
    final JPQLQuery<T> query = createQuery(predicate)
            .select(path)
            .offset(page.getOffset())
            .limit(page.getPageSize() + 1);
    return toSlice(querydsl.applySorting(page.getSort(), query).fetch(), page);
}

private static <S> Slice<S> toSlice(final List<S> results, final Pageable page) {
    boolean hasNext = false;
    if (results.size() > page.getPageSize()) {
        // Remove the extra element
        results.remove(results.size() - 1);
        hasNext = true;
    }
    return new SliceImpl<>(results, page, hasNext);
}

@CacheControl(policy = CachePolicy.NO_CACHE)
@RequestMapping(method = RequestMethod.GET)
public Slice<ListAnnouncementDTO> listAnnouncements(@RequestParam final OrganisationType organisationType,
                                                    @RequestParam final String officialCode,
                                                    @RequestParam final ListAnnouncementRequest.Direction direction,
                                                    Pageable pageRequest) {
    final ListAnnouncementRequest request = new ListAnnouncementRequest();
    request.setOrganisationType(organisationType);
    request.setOfficialCode(officialCode);
    request.setDirection(direction);

    return listAnnouncementFeature.list(request, pageRequest);
}

@RequestMapping(
        method = RequestMethod.GET,
        value = "announcements")
public Slice<ListAnnouncementDTO> myAnnouncements(
        @PageableDefault(size = 500, sort = "id", direction = Sort.Direction.ASC) Pageable pageRequest) {
    final ListAnnouncementRequest request = new ListAnnouncementRequest();
    request.setDirection(ListAnnouncementRequest.Direction.RECEIVED);
    return listAnnouncementFeature.list(request, pageRequest);
}

public void rotate() {
  final long start = System.currentTimeMillis();
  logger.info("Starting encryption key rotation.");
  int rotatedRecordCount = 0;

  final long startingNotRotatedRecordCount = encryptedValueDataService
      .countAllByCanaryUuid(keySet.getActive().getUuid());

  List<UUID> inactiveCanaries = keySet.getInactiveUuids();
  Slice<EncryptedValue> valuesEncryptedByOldKey = encryptedValueDataService
      .findByCanaryUuids(inactiveCanaries);
  while (valuesEncryptedByOldKey.hasContent()) {
    for (EncryptedValue value : valuesEncryptedByOldKey.getContent()) {
      try {
        encryptedValueDataService.rotate(value);
        rotatedRecordCount++;
      } catch (KeyNotFoundException e) {
        logger.error("key not found for value, unable to rotate");
      }
    }
    valuesEncryptedByOldKey = encryptedValueDataService.findByCanaryUuids(inactiveCanaries);
  }

  final long finish = System.currentTimeMillis();
  final long duration = finish - start;
  final long endingNotRotatedRecordCount = startingNotRotatedRecordCount - rotatedRecordCount;

  if (rotatedRecordCount == 0 && endingNotRotatedRecordCount == 0) {
    logger.info("Found no records in need of encryption key rotation.");
  } else {
    logger.info("Finished encryption key rotation in " + duration + " milliseconds. Details:");
    logger.info("  Successfully rotated " + rotatedRecordCount + " item(s)");
    logger.info("  Skipped " + endingNotRotatedRecordCount
        + " item(s) due to missing master encryption key(s).");
  }

  encryptionKeyCanaryMapper.delete(inactiveCanaries);
}

@Test
public void findByCanaryUuids() throws Exception {
  List<UUID> canaryUuids = Collections.singletonList(UUID.randomUUID());
  Slice<EncryptedValue> encryptedValues = new SliceImpl(Collections.singletonList(new EncryptedValue()));
  when(encryptedValueRepository.findByEncryptionKeyUuidIn(eq(canaryUuids), any())).thenReturn(encryptedValues);

  assertThat(subject.findByCanaryUuids(canaryUuids), equalTo(encryptedValues));
}

@Override
public Slice<Rollout> findByFiltersWithDetailedStatus(final Pageable pageable, final String searchText,
        final boolean deleted) {
    final Slice<JpaRollout> findAll = findByCriteriaAPI(pageable,
            Arrays.asList(JpaRolloutHelper.likeNameOrDescription(searchText, deleted)));
    setRolloutStatusDetails(findAll);
    return JpaRolloutHelper.convertPage(findAll, pageable);
}

private void setRolloutStatusDetails(final Slice<JpaRollout> rollouts) {
    final List<Long> rolloutIds = rollouts.getContent().stream().map(Rollout::getId).collect(Collectors.toList());
    final Map<Long, List<TotalTargetCountActionStatus>> allStatesForRollout = getStatusCountItemForRollout(
            rolloutIds);

    if (allStatesForRollout != null) {
        rollouts.forEach(rollout -> {
            final TotalTargetCountStatus totalTargetCountStatus = new TotalTargetCountStatus(
                    allStatesForRollout.get(rollout.getId()), rollout.getTotalTargets());
            rollout.setTotalTargetCountStatus(totalTargetCountStatus);
        });
    }
}

@Override
public Slice<Target> findByTargetFilterQuery(final Pageable pageable, final Long targetFilterQueryId) {
    final TargetFilterQuery targetFilterQuery = targetFilterQueryRepository.findById(targetFilterQueryId)
            .orElseThrow(() -> new EntityNotFoundException(TargetFilterQuery.class, targetFilterQueryId));

    return findTargetsBySpec(
            RSQLUtility.parse(targetFilterQuery.getQuery(), TargetFields.class, virtualPropertyReplacer), pageable);
}

private Slice<Target> findByCriteriaAPI(final Pageable pageable, final List<Specification<JpaTarget>> specList) {
    if (CollectionUtils.isEmpty(specList)) {
        return convertPage(criteriaNoCountDao.findAll(pageable, JpaTarget.class), pageable);
    }
    return convertPage(
            criteriaNoCountDao.findAll(SpecificationsBuilder.combineWithAnd(specList), pageable, JpaTarget.class),
            pageable);
}

@Override
public Slice<SoftwareModule> findByType(final Pageable pageable, final Long typeId) {
    throwExceptionIfSoftwareModuleTypeDoesNotExist(typeId);

    final List<Specification<JpaSoftwareModule>> specList = Lists.newArrayListWithExpectedSize(2);

    specList.add(SoftwareModuleSpecification.equalType(typeId));
    specList.add(SoftwareModuleSpecification.isDeletedFalse());

    return convertSmPage(findByCriteriaAPI(pageable, specList), pageable);
}