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

/** 자기가 진행중인 저장소의 글을 검색함.
 * @param privateAndMassageTags
 * @param search
 * @param sort
 * @param page
 * @param size
 * @return
 */
public List<Post> getMyRepositoryPosts(List<String> privateAndMassageTags, String search, 
        String sort, int page,int size) {
    Criteria criteria = new Criteria();

    criteria.and("tags").in(privateAndMassageTags);

    if (search != null)
        criteria.andOperator(new Criteria().orOperator(
                Criteria.where("title").regex(search),
                Criteria.where("content").regex(search)));

    this.filter(criteria, sort);

    Query query = new Query(criteria);
    query.with(new PageRequest(page - 1, size));

    this.sorting(query, sort);
    return mongoTemplate.find(query, Post.class);
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public PageWrapper<User> findBy(FindUserDTO dto, int page, int size) {
    List<String> roleStr = null;
    String usernameOrEmail;

    if (dto.getRole() == null) {

        if (UserUtils.isAdmin())
            roleStr = Arrays.asList(RoleEnum.PROFESSOR.name(), RoleEnum.STUDENT.name());

        else if (UserUtils.isProfessor())
            roleStr = Arrays.asList(RoleEnum.STUDENT.name());

    } else {
        roleStr = Arrays.asList(dto.getRole().name());
    }

    usernameOrEmail = StringUtils.isEmpty(dto.getUsernameOrEmail()) ? "%%" : "%".concat(dto.getUsernameOrEmail().toLowerCase()).concat("%");

    Pageable pageable = new PageRequest(page, size);
    Page<User> pageInterface = userRepository.findBy(roleStr, usernameOrEmail, pageable);

    return new PageWrapper(pageInterface.getContent(), pageable, pageInterface.getTotalElements());
}

public void saveAndBroadcast(InboundSmsMessage smsMessage){
    log.info("Inbound message received {}", smsMessage);

    inboundSmsMessageRepository.save(smsMessage);

    Pageable page = (Pageable) PageRequest.of(0, 1, Direction.DESC, "date");
    List<Conversation> conversations = conversationRepository.findByPhoneNumber(smsMessage.getMsisdn(), page);

    if( ! conversations.isEmpty()){
        Conversation conversation =  conversations.get(0);
        Optional<Participant> user = conversation.findParticipantByPhone(smsMessage.getMsisdn());

        if(user.isPresent()){
            ConversationMessage conversationMessage = createConversationMessage(smsMessage, conversation, user.get());
            broadcastMessage(conversationMessage);
        }else{
            log.warn("No participant found associated with {} in {}", smsMessage.getMsisdn(), conversation.getId());
        }

    }else{
        log.warn("No conversation found associated with {}", smsMessage.getMsisdn());
    }
}

/**
 * Create pageable request with default sort.
 *
 * @param page Page.
 * @param defaultSort Default sort object.
 * @param caseSensitiveSortProperties List of case sensitive properties or {@link #CASE_SENSITIVE_PROPERTIES} for
 *                                       all properties to be case sensitive.
 * @return Page object.
 */
public static PageRequest createPageRequest(Pageable page, Sort defaultSort,
                                            Collection<String> caseSensitiveSortProperties) {
    Sort sort = page.getSort();
    sort = sort == null ? defaultSort : sort.and(defaultSort);

    List<Sort.Order> ignoreCaseOrderList = Collections.emptyList();
    if (sort != null) {
        ignoreCaseOrderList = StreamUtils.createStreamFromIterator(sort.iterator())
                .map(order -> {
                    if (caseSensitiveSortProperties == CASE_SENSITIVE_PROPERTIES ||
                            caseSensitiveSortProperties.contains(order.getProperty())) {
                        return order.ignoreCase();
                    }
                    return order;
                })
                .collect(Collectors.toList());
    }

    if (ignoreCaseOrderList.isEmpty()) {
        return new PageRequest(page.getPageNumber(), page.getPageSize());
    }
    return new PageRequest(page.getPageNumber(), page.getPageSize(), new Sort(ignoreCaseOrderList));
}

@Override
public List<City> searchCity(Integer pageNumber,
                             Integer pageSize,
                             String searchContent) {
    // 分页参数
    Pageable pageable = new PageRequest(pageNumber, pageSize);

    // Function Score Query
    FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery()
            .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("cityname", searchContent)),
                ScoreFunctionBuilders.weightFactorFunction(1000))
            .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("description", searchContent)),
                    ScoreFunctionBuilders.weightFactorFunction(100));

    // 创建搜索 DSL 查询
    SearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withPageable(pageable)
            .withQuery(functionScoreQueryBuilder).build();

    LOGGER.info("\n searchCity(): searchContent [" + searchContent + "] \n DSL  = \n " + searchQuery.getQuery().toString());

    Page<City> searchPageResults = cityRepository.search(searchQuery);
    return searchPageResults.getContent();
}

/** 관리자가 글을 불러올 때
 * @param tags
 * @param search
 * @param writer
 * @param sort
 * @param page
 * @param size
 * @return
 */
public List<Post> getPostsAsAdmin(List<String> tags, String search, Weaver writer, String sort,
        int page, int size) {
    Criteria criteria = new Criteria();

    if (search != null)
        criteria.orOperator(new Criteria("title").regex(search),
                new Criteria("content").regex(search));

    if (tags != null)
        criteria.and("tags").all(tags);
    if (writer != null)
        criteria.and("writer").is(writer);

    this.filter(criteria, sort);

    Query query = new Query(criteria);

    query.with(new PageRequest(page - 1, size));
    this.sorting(query, sort);

    return mongoTemplate.find(query, Post.class);
}

/** 저장소를 검색
 * @param tags
 * @param search
 * @param creator
 * @param sort
 * @param page
 * @param size
 * @return
 */
public List<Repository> getRepositories( 
        List<String> tags,
        String search,
        String sort,
        int page, 
        int size) {
    Criteria criteria = new Criteria();

    if(search != null && search.length()>0)
        criteria.orOperator(new Criteria("name").regex(search),
                new Criteria("description").regex(search));

    if(tags != null)
        criteria.and("tags").all(tags);

    this.filter(criteria, sort);

    Query query = new Query(criteria);
    query.with(new PageRequest(page-1, size));

    this.sorting(query, sort);
    return mongoTemplate.find(query, Repository.class);
}

/**
 * Sorted direction with ordering and corresponding ORM column.
 */
@Test
public void getPageRequestFullOrderingMixProvider() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add(DataTableAttributes.PAGE_LENGTH, "100");
    uriInfo.getQueryParameters().add("sidx", "col1");
    uriInfo.getQueryParameters().add("sortd", "asc");
    final Map<String, String> map = Collections.singletonMap("col1", "colOrm");
    final PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, map);
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    Assert.assertNull(pageRequest.getSort().getOrderFor("colOrm?"));
    Assert.assertNotNull(pageRequest.getSort().getOrderFor("colOrm"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("colOrm").getDirection());
    Assert.assertTrue(pageRequest.getSort().getOrderFor("colOrm").isIgnoreCase());
    Assert.assertEquals(100, pageRequest.getPageSize());
}

/**
 * @param value
 * @param inclureDossierOtherYears
 * @param exactSearch
 * @return la liste des compte grace a un filtre pour la recherche de compte candidat
 */
public List<CompteMinima> getCptMinByFilter(String value, final Boolean inclureDossierOtherYears,
        final Boolean exactSearch) {
    if (!exactSearch) {
        value = "%" + value + "%";
    }
    if (inclureDossierOtherYears) {
        return compteMinimaRepository.findByFilterAllYears(value,
                new PageRequest(0, ConstanteUtils.NB_MAX_RECH_CPT_MIN));
    } else {
        Campagne campagne = campagneController.getCampagneActive();
        if (value == null || campagne == null) {
            return new ArrayList<>();
        }
        return compteMinimaRepository.findByFilter(campagne.getCodCamp(), value,
                new PageRequest(0, ConstanteUtils.NB_MAX_RECH_CPT_MIN));
    }
}

/**
 * Sorted direction with ordering and corresponding ORM column.
 */
@Test
public void getPageRequestIdentityMapping() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add("sidx", "col1");
    uriInfo.getQueryParameters().add("sortd", "asc");
    final Map<String, String> map = Collections.singletonMap("*", "*");
    final PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, map);
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    Assert.assertNull(pageRequest.getSort().getOrderFor("col1?"));
    Assert.assertNotNull(pageRequest.getSort().getOrderFor("col1"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("col1").getDirection());
    Assert.assertTrue(pageRequest.getSort().getOrderFor("col1").isIgnoreCase());
    Assert.assertEquals(10, pageRequest.getPageSize());
}

@Test
public void testFindByUserIdSorted_withValidQuery_shouldReturnCorrectSortedByPinnedAndLastEditedDescending() {

    List<Note> firstFive = dao.findByUserIdSorted(1l, new PageRequest(0, 5));

    assertEquals("check latest pinned", "1-pinned-latest", firstFive.get(0).getTitle());
    assertEquals("check second pinned", "2-pinned-second", firstFive.get(1).getTitle());
    assertEquals("check third pinned", "3-pinned-third", firstFive.get(2).getTitle());
    assertEquals("check real latest non-pinned", "1latest", firstFive.get(3).getTitle());
    assertEquals("check second non-pinned", "2second", firstFive.get(4).getTitle());

    List<Note> secondFive = dao.findByUserIdSorted(1l, new PageRequest(1, 5));

    assertEquals("check third", "3thrid", secondFive.get(0).getTitle());
    assertEquals("check fourth", "4fourth", secondFive.get(1).getTitle());
    assertEquals("check fifth", "5fifth", secondFive.get(2).getTitle());
    assertEquals("check second oldest", "second oldest", secondFive.get(3).getTitle());
    assertEquals("check oldest",
            "oldest-non-pinned. Capicola kevin ham hock, pancetta ribeye beef ribs short loin pork loin sirloin tail pig porchetta boudin. Chuck porchetta meatloaf, beef ham swine tenderloin tail.",
            secondFive.get(4).getTitle());

}

@Override
public IssuerWithKeys getOrCreateDemoIssuer() {
    IssuerEntity demoIssuer = issuerRepository.findByName(DEMO_ISSUER_NAME, new PageRequest(0, 1))
            .getContent()
            .stream()
            .findFirst()
            .orElseGet(() -> this.createDemoIssuerWithKeys().getIssuer());

    String privateKeyBase64 = demoIssuer.getPrivateKeyBase64()
            .orElseThrow(IllegalArgumentException::new);

    return IssuerWithKeys.builder()
            .issuer(demoIssuer)
            .publicKey(KeyImpl.fromBase64(demoIssuer.getPublicKeyBase64()))
            .privateKey(KeyImpl.fromBase64(privateKeyBase64))
            .build();
}

@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()));
}

@Test
public void testFindArchivedNotesByUserIdPaginated_withCorrectUserIdFirstPage4Items_shouldReturnCorrectAndSorted() {
    List<OverviewNote> notes = service.findArchivedNotesByUserIdPaginated(1l, new PageRequest(0, 4));

    assertEquals("should return 4 notes", 4, notes.size());
    assertTrue("should contain first pinned entry", notes.get(0).getTitle().equals("a1-pinned-latest"));
    assertTrue("should contain second pinned entry", notes.get(1).getTitle().equals("a2-pinned-second"));
    assertTrue("should contain third pinned entry", notes.get(2).getTitle().equals("a3-pinned-third"));
    assertTrue("should contain first regular entry", notes.get(3).getTitle().equals("a1latest"));
    OverviewNote firstNote = notes.get(0);
    Note expectedFirst = archivedDao.findOne(firstNote.getId());

    assertEquals("check last edit", expectedFirst.getLastEdit(), firstNote.getLastEdit());
    assertEquals("check if part content is part of content",
            StringUtils.abbreviate(expectedFirst.getContent(), NotesServiceImpl.OVERVIEW_CONTENT_PART_LENGTH),
            firstNote.getPartContent());
    assertEquals("check title", expectedFirst.getTitle(), firstNote.getTitle());
    assertEquals("check pinned", expectedFirst.getPinned(), firstNote.getPinned());
}

@Override
public Page<User> queryPage(SysRole role, UserQueryRequest queryRequest) {
    int start = queryRequest.getStart();
    int limit = queryRequest.getLimit();
    Query query = new Query();
    query.addCriteria(Criteria.where("roles").in(role));
    if (!StringUtils.isEmpty(queryRequest.getUsername())) {
        query.addCriteria(Criteria.where("username").regex(queryRequest.getUsername()));
    }
    query.addCriteria(Criteria.where("deleted").ne(true));

    PageRequest pageable = new PageRequest(start, limit, new Sort(Sort.Direction.DESC, "username"));
    query.with(pageable);
    long count = mongoTemplate.count(query, User.class);
    List<User> list = mongoTemplate.find(query, User.class);

    return new PageImpl<>(list, pageable, count);
}

/**
 * Sorted direction with ordering and corresponding ORM column.
 */
@Test
public void getPageRequestFullOrderingAlias() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add(DataTableAttributes.PAGE_LENGTH, "100");
    uriInfo.getQueryParameters().add(DataTableAttributes.SORTED_COLUMN, "2");
    uriInfo.getQueryParameters().add("columns[2][data]", "col1");
    uriInfo.getQueryParameters().add(DataTableAttributes.SORT_DIRECTION, "asc");
    final Map<String, String> map = Collections.singletonMap("col1", "c.colOrm");
    final PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, map);
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    Assert.assertNull(pageRequest.getSort().getOrderFor("c.colOrm?"));
    Assert.assertNotNull(pageRequest.getSort().getOrderFor("UPPER(c.colOrm)"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("UPPER(c.colOrm)").getDirection());
    Assert.assertEquals(100, pageRequest.getPageSize());
}

@RequestMapping("articleList")
public PageableResultJson articleList(@RequestParam(value = "page") Integer page, Long id, String title) {
    PageableResultJson tableJson = new PageableResultJson();
    Sort sort = new Sort(Direction.DESC, "id");
    Pageable pageable = new PageRequest(page, PageableResultJson.PAGE_SIZE, sort);
    Page<Article> pageData = null;
    if (StringUtils.isEmpty(title)) {
        pageData = articleDao.findArticleByAuthorId(id, pageable);
    } else {
        pageData = articleDao.findArticleByAuthorIdAndTitleLike(id, title, pageable);
    }

    tableJson.setData(pageData.getContent());
    tableJson.setPageSize(PageableResultJson.PAGE_SIZE);
    tableJson.setTotalPageNumber(pageData.getTotalPages());
    return tableJson;
}

/**
 *
 *
 *
 * @param pageNumber
 * @param pageSize
 * @param searchContent
 * @return
 */
public List<GoodsModel> searchGoods(Integer pageNumber,
                                    Integer pageSize,
                                    String searchContent) {
    // 分页参数
    Pageable pageable = new PageRequest(pageNumber, pageSize);

    // Function Score Query
    FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery()
            .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("goodsName", searchContent)),ScoreFunctionBuilders.weightFactorFunction(1000))
            .add(QueryBuilders.boolQuery().should(QueryBuilders.matchQuery("description", searchContent)),ScoreFunctionBuilders.weightFactorFunction(1000));

    // 创建搜索 DSL 查询
    SearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withPageable(pageable)
            .withQuery(functionScoreQueryBuilder).build();

    logger.info("\n searchGoods(): searchContent [" + searchContent + "] \n DSL  = \n " + searchQuery.getQuery().toString());

    Page<GoodsModel> searchPageResults = goodsESDocRepository.search(searchQuery);
    return searchPageResults.getContent();
}

/**
 * 根据搜索词构造搜索查询语句
 *
 * 代码流程：
 *      - 权重分查询
 *      - 短语匹配
 *      - 设置权重分最小值
 *      - 设置分页参数
 *
 * @param pageNumber 当前页码
 * @param pageSize 每页大小
 * @param searchContent 搜索内容
 * @return
 */
private SearchQuery getCitySearchQuery(Integer pageNumber, Integer pageSize,String searchContent) {
    // 短语匹配到的搜索词，求和模式累加权重分
    // 权重分查询 https://www.elastic.co/guide/cn/elasticsearch/guide/current/function-score-query.html
    //   - 短语匹配 https://www.elastic.co/guide/cn/elasticsearch/guide/current/phrase-matching.html
    //   - 字段对应权重分设置，可以优化成 enum
    //   - 由于无相关性的分值默认为 1 ，设置权重分最小值为 10
    FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery()
            .add(QueryBuilders.matchPhraseQuery("name", searchContent),
            ScoreFunctionBuilders.weightFactorFunction(1000))
            .add(QueryBuilders.matchPhraseQuery("description", searchContent),
            ScoreFunctionBuilders.weightFactorFunction(500))
            .scoreMode(SCORE_MODE_SUM).setMinScore(MIN_SCORE);

    // 分页参数
    Pageable pageable = new PageRequest(pageNumber, pageSize);
    return new NativeSearchQueryBuilder()
            .withPageable(pageable)
            .withQuery(functionScoreQueryBuilder).build();
}

@Test
public void generatePaginationHttpHeadersTest() {
    String baseUrl = "/api/_search/example";
    List<String> content = new ArrayList<>();
    Page<String> page = new PageImpl<>(content,new PageRequest(6, 50),400L);
    HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, baseUrl);
    List<String> strHeaders = headers.get(HttpHeaders.LINK);
    assertNotNull(strHeaders);
    assertTrue(strHeaders.size() == 1);
    String headerData = strHeaders.get(0);
    assertTrue(headerData.split(",").length == 4);
    String expectedData = "</api/_search/example?page=7&size=50>; rel=\"next\","
            + "</api/_search/example?page=5&size=50>; rel=\"prev\","
            + "</api/_search/example?page=7&size=50>; rel=\"last\","
            + "</api/_search/example?page=0&size=50>; rel=\"first\"";
    assertEquals(expectedData, headerData);
    List<String> xTotalCountHeaders = headers.get("X-Total-Count");
    assertTrue(xTotalCountHeaders.size() == 1);
    assertTrue(Long.valueOf(xTotalCountHeaders.get(0)).equals(400L));
}

/** 태그를 이용하여 위버를 검색함.
 * @param tags
 * @param page
 * @param size
 * @return 회원 목록
 */
public List<Weaver> getWeavers(List<String> tags, int page,int size) {
    Criteria criteria = new Criteria("tags").all(tags).and("isLeave").is(false);

    Query query = new Query(criteria);
    query.with(new PageRequest(page - 1, size));

    return mongoTemplate.find(query, Weaver.class);
}

@Test
@Sql(scripts = "/sql/favorites/favorites.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/sql/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
public void testSearchByAppId() {
  List<Favorite> favorites = favoriteService.search(null, "test0621-04", new PageRequest(0, 10));
  Assert.assertEquals(3, favorites.size());
}

@Override
public FacetPage<Product> findByFacetOnCategory(Pageable pageable) {

    FacetQuery query = new
            SimpleFacetQuery(new Criteria(IProduct.DOCTYPE_FIELD)
                    .is(SolrDocType.PRODUCT));

    query.setFacetOptions(new FacetOptions(Product.CATEGORY_FIELD)
            .setPageable(new PageRequest(0,20)));

    return getSolrOperations().queryForFacetPage(query, Product.class);
}

@GetMapping("/estates/all/{page}")
public byte[] listAllByPage(@PathVariable("page") int page) {
    pageable = new PageRequest(page - 1, 100);
    List<EstateItemDTO> list = estateService.listAllByPage(pageable);
    if (CollectionUtils.isNotEmpty(list)) {
        return ProtoStuffUtil.serializeList(list);
    }
    return null;
}

@Test
public void testFindPublicAppNamespace() {

  AppNamespace publicAppNamespace = MockBeanFactory.mockAppNamespace(null, testPublicAppNamespace, true);
  when(appNamespaceService.findPublicNamespaceByName(testPublicAppNamespace)).thenReturn(publicAppNamespace);

  Namespace firstParentNamespace =
      MockBeanFactory.mockNamespace("app", ConfigConsts.CLUSTER_NAME_DEFAULT, testPublicAppNamespace);
  Namespace secondParentNamespace =
      MockBeanFactory.mockNamespace("app1", ConfigConsts.CLUSTER_NAME_DEFAULT, testPublicAppNamespace);
  Namespace childNamespace =
      MockBeanFactory.mockNamespace("app2", ConfigConsts.CLUSTER_NAME_DEFAULT, testPublicAppNamespace);


  Pageable page = new PageRequest(0, 10);

  when(namespaceRepository.findByNamespaceName(testPublicAppNamespace, page))
      .thenReturn(Arrays.asList(firstParentNamespace, secondParentNamespace));

  doReturn(false).when(namespaceService).isChildNamespace(firstParentNamespace);
  doReturn(false).when(namespaceService).isChildNamespace(secondParentNamespace);
  doReturn(true).when(namespaceService).isChildNamespace(childNamespace);

  List<Namespace> namespaces = namespaceService.findPublicAppNamespaceAllNamespaces(testPublicAppNamespace, page);

  assertEquals(2, namespaces.size());
}

/**
 * Counts all instances that respect the selected {@link Params}.
 *
 * <p>
 *     Though {@link Params} one could specify filtering. For further explanation
 *     see {@link Params}.
 * </p>
 *
 * @param params Parameters to comply with
 * @return Total number of instances
 */
default Long count(Params params) {
    SimpleQuery query = new SimpleQuery();
    query.addCriteria(typeCriteria());
    query.addSort(new Sort(new Sort.Order(Sort.Direction.valueOf(params.getOrder().toString()), params.getSort())));
    query.addProjectionOnField("id");
    query.setPageRequest(new PageRequest(params.getPage(), params.getPageSize()));
    query.addFilterQuery(new SimpleFilterQuery(buildFilters(params)));

    Page<U> page = getTemplate().query(query, getUType());
    return page.getTotalElements();
}

@Transactional(readOnly = true)
public void initNewPosts() {
    // Load all post ids from database to Redis
    PageRequest page = new PageRequest(0, Integer.MAX_VALUE, Sort.Direction.ASC, "id");
    Page<Post> posts = postRepository.findPublicPosts(page, PostStatus.PUBLIC);
    posts.forEach(post -> {
        this.add(post);
        this.addTaggedPost(post, tagRepository.findPostTags(post.getId()));
    });
}

@Override
public Page<Article> getPublishedArticleByPage(int pageNum, int pageSize) {
    Page<Article> articles = articleRepository.findByStatus(
            new PageRequest(pageNum, pageSize, Sort.Direction.DESC, "id"), 2);
    articles.forEach(article -> {
        int moreIndex = article.getContent().indexOf("<!--more-->");
        if (moreIndex > 0) {
            article.setContent(article.getContent().substring(0, moreIndex));
        }
    });
    return articles;
}

/**
 * No sorted direction.
 */
@Test
public void getPageRequestSortedDirection() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add(DataTableAttributes.PAGE_LENGTH, "100");
    uriInfo.getQueryParameters().add(DataTableAttributes.SORTED_COLUMN, "2");
    final PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, null);
    Assert.assertNotNull(pageRequest);
    Assert.assertFalse(pageRequest.getSort().isSorted());
    Assert.assertEquals(0, pageRequest.getOffset());
}

/**
 * GET  /admin/tags -> get all the tags.
 */
@RequestMapping(value = "/admin/tags",
    method = RequestMethod.GET,
    produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public ResponseEntity<List<Tag>> getAllTags(Pageable pageable)
    throws URISyntaxException {
    Pageable pageRequest = new PageRequest(pageable.getPageNumber(), pageable.getPageSize(), Sort.Direction.DESC, "id");
    Page<Tag> page = tagRepository.findAll(pageRequest);
    HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, "/api/admin/tags");
    return new ResponseEntity<>(page.getContent(), headers, HttpStatus.OK);
}

@Test
public void testPage() {
    int page = 0, size = 10;
    Sort sort = new Sort(Sort.Direction.DESC, "id");
    Pageable pageable = new PageRequest(page, size, sort);
    Page<User> all = userRepository.findAll(pageable);
    all.forEach(e -> log.info("testPage:{}", e));
}

@Test
public void testPaging() {
    Page<User> userPage = pagingUserInterface.findAll(new PageRequest(0, 5));

    List<User> users = userPage.getContent();
    Assert.assertThat(users, hasSize(5));
    Assert.assertThat(
            users.stream().map(it -> it.id).collect(Collectors.toList()),
            contains(LongStream.rangeClosed(1, 5).boxed().toArray(Long[]::new))
    );
}

@Override
public Page<AuditEventAggregation> listAuditReportByDay(String realm, PageQueryParameter queryRequest) {
    return auditEventAggregationRepository.findPageByRealmAndAggregationTypeOrderByAggregationKeyDesc(realm,
                                                                                                      AggregationType.DAY,
                                                                                                      new PageRequest(
                                                                                                              queryRequest
                                                                                                                      .getStart(),
                                                                                                              queryRequest
                                                                                                                      .getLimit()));
}

@Override
public List<Device> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink) {
  return DaoUtil.convertDataList(
      deviceRepository.findByTenantId(fromTimeUUID(tenantId), Objects.toString(pageLink.getTextSearch(), ""),
          pageLink.getIdOffset() == null ? NULL_UUID_STR : fromTimeUUID(pageLink.getIdOffset()),
          new PageRequest(0, pageLink.getLimit())));
}

@Override
public Page<AuthEventAggregation> listAuthReportByMonth(String realm, PageQueryParameter queryRequest) {
    return authEventAggregationRepository.findPageByRealmAndAggregationTypeOrderByAggregationKeyDesc(realm,
                                                                                                     AggregationType.MONTH,
                                                                                                     new PageRequest(
                                                                                                             queryRequest
                                                                                                                     .getStart(),
                                                                                                             queryRequest
                                                                                                                     .getLimit()));
}

@Test
public void findByCriteria_validPage_returnUsersPage() {
    final Pageable page = new PageRequest(0, 10);
    final Page<User> expectedUsers = new PageImpl<>(Arrays.asList(USER_1, USER_2));

    when(usersRepositoryMock.findAll(page)).thenReturn(expectedUsers);

    Page<User> users = usersService.findByCriteria(page);

    assertThat(users, equalTo(expectedUsers));
}

public ApplicationEntity getOrCreateDemoApplication() {
    return applicationRepository.findByName(DEMO_APP_NAME, new PageRequest(0, 1))
            .getContent()
            .stream()
            .findFirst()
            .orElseGet(this::createDemoApplication);
}

@Override
public PageDTO findAllQuestion(int page) {
    Page<Question> list = questionRepository.findAll(new PageRequest(page,10,
            new Sort(Sort.Direction.DESC,"creationDate")));
    List<QuestionDTO> DTOs = new ArrayList<>();
    list.forEach(question -> DTOs.add(new QuestionDTO(question,questionVoteRepository.countAllByQuestion(question))));
    return new PageDTO(list,DTOs);
}

@Override
public Page<NewsSummary> listNews(NewsQueryParameter queryRequest) {
    Page<News> newsPage = newsService.listNews(queryRequest);
    return new PageImpl<>(newsPage.getContent().stream().map(NewsSummary::from).collect(Collectors.toList()),
                          new PageRequest(queryRequest.getStart(), queryRequest.getLimit()),
                          newsPage.getTotalElements());
}

@RequestMapping("/list.do")
@ResponseBody
public ResultBean<List<Classification>> findAll(int type,
                                                int pageindex, @RequestParam(value = "pageSize", defaultValue = "15") int pageSize) {
    List<Classification> list = new ArrayList<>();
    if (pageindex == -1)
        list = classificationService.findAll(type);
    else {
        Pageable pageable = new PageRequest(pageindex, pageSize, null);
        list = classificationService.findAll(type, pageable).getContent();
    }
    return new ResultBean<>(list);
}