Java 类org.springframework.data.domain.Sort.Direction 实例源码

/**
 * Get number of books that were published by the particular publisher with their titles.
 */
@Test
public void shouldRetrieveBooksPerPublisherWithTitles() {

    Aggregation aggregation = newAggregation( //
            group("volumeInfo.publisher") //
                    .count().as("count") //
                    .addToSet("volumeInfo.title").as("titles"), //
            sort(Direction.DESC, "count"), //
            project("count", "titles").and("_id").as("publisher"));

    AggregationResults<BooksPerPublisher> result = operations.aggregate(aggregation, "books", BooksPerPublisher.class);

    BooksPerPublisher booksPerPublisher = result.getMappedResults().get(0);

    assertThat(booksPerPublisher.getPublisher()).isEqualTo("Apress");
    assertThat(booksPerPublisher.getCount()).isEqualTo(26);
    assertThat(booksPerPublisher.getTitles()).contains("Expert Spring MVC and Web Flow", "Pro Spring Boot");
}

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

/**
 * Creates a 'LIMIT .. OFFSET .. ORDER BY ..' clause for the given
 * {@link DataTablesInput}.
 * 
 * @param input
 *            the {@link DataTablesInput} mapped from the Ajax request
 * @return a {@link Pageable}, must not be {@literal null}.
 */
@Transactional
private Pageable getPageable(DataTablesInput input) {

    List<Order> orders = new ArrayList<Order>();
    for (OrderParameter order : input.getOrder()) {
        log.debug("order column: " + order.getColumn() + "");
        ColumnParameter column = input.getColumns().get(order.getColumn());
        if (column.getOrderable()) {
            String sortColumn = column.getData();
            Direction sortDirection = Direction.fromString(order.getDir());
            orders.add(new Order(sortDirection, sortColumn));
        }
    }
    Sort sort = orders.isEmpty() ? null : new Sort(orders);
    if (input.getLength() == -1) {
        input.setStart(0);
        input.setLength(Integer.MAX_VALUE);
    }

    return new PageRequest(input.getStart() / input.getLength(), input.getLength(), sort);
}

@Override
public Page<T> findAll(final Set<T> groups, final String criteria, final Pageable pageable, final Map<String, Comparator<T>> customComparators) {
    // Create the set with the right comparator
    final List<Sort.Order> orders = IteratorUtils.toList(ObjectUtils.defaultIfNull(pageable.getSort(), new ArrayList<Sort.Order>()).iterator());
    orders.add(DEFAULT_ORDER);
    final Sort.Order order = orders.get(0);
    Comparator<T> comparator = customComparators.get(order.getProperty());
    if (order.getDirection() == Direction.DESC) {
        comparator = Collections.reverseOrder(comparator);
    }
    final Set<T> result = new TreeSet<>(comparator);

    // Filter the groups, filtering by the criteria
    addFilteredByPattern(groups, criteria, result);

    // Apply in-memory pagination
    return inMemoryPagination.newPage(result, pageable);
}

/**
 * 方法名 ： findAll
 * 功 能 ： TODO(这里用一句话描述这个方法的作用)
 * 参 数 ： @return
 * 参 考 ： @see tk.ainiyue.admin.roles.service.SysRolesService#findAll()
 * 作 者 ： Tenghui.Wang
 */

@Override
public Page<SysSeedInfo> findAll(int pageNumber, int pageSize, String searchText) {
    Sort sort = new Sort(new Order(Direction.DESC, "seedName"));
    PageRequest request = this.buildPageRequest(pageNumber, pageSize, sort);
    Page<SysSeedInfo> sourceCodes = null;
    if (searchText == null || "".equals(searchText)) {
        sourceCodes = sysSeedDao.findAll(request);
    } else {
        SysSeedInfo info = new SysSeedInfo();
        info.setSeedName(searchText);
        Example<SysSeedInfo> example = Example.of(info);
        sourceCodes = sysSeedDao.findAll(example, request);
    }
    return sourceCodes;
}

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

public static <T> List<Order> getOrdes(String orderBy) {
    if (StringUtils.isEmpty(orderBy)) {
        return Collections.emptyList();
    }
    String[] groups = orderBy.trim().split(",");
    List<Order> orders = new ArrayList<Order>(groups.length);
    for (String group : groups) {
        boolean ascending = true;
        String[] array = group.split("\\s", 2);
        String property = array[0];
        if (array.length > 1) {
            ascending ="asc".equalsIgnoreCase(array[0]);;
        }
        Order order = new Order(ascending ? Direction.ASC : Direction.DESC, property);
        orders.add(order);
    }
    return orders;
}

/**
 * Get number of books that were published by the particular publisher.
 */
@Test
public void shouldRetrieveBooksPerPublisher() {

    Aggregation aggregation = newAggregation( //
            group("volumeInfo.publisher") //
                    .count().as("count"), //
            sort(Direction.DESC, "count"), //
            project("count").and("_id").as("publisher"));

    AggregationResults<BooksPerPublisher> result = operations.aggregate(aggregation, "books", BooksPerPublisher.class);

    assertThat(result).hasSize(27);
    assertThat(result).extracting("publisher").containsSequence("Apress", "Packt Publishing Ltd");
    assertThat(result).extracting("count").containsSequence(26, 22, 11);
}

/**
 * Filter for Data-related books in their title and output the title and authors.
 */
@Test
public void shouldRetrieveDataRelatedBooks() {

    Aggregation aggregation = newAggregation( //
            match(Criteria.where("volumeInfo.title").regex("data", "i")), //
            replaceRoot("volumeInfo"), //
            project("title", "authors"), //
            sort(Direction.ASC, "title"));

    AggregationResults<BookAndAuthors> result = operations.aggregate(aggregation, "books", BookAndAuthors.class);

    BookAndAuthors bookAndAuthors = result.getMappedResults().get(1);

    assertThat(bookAndAuthors.getTitle()).isEqualTo("Spring Data");
    assertThat(bookAndAuthors.getAuthors()).contains("Mark Pollack", "Oliver Gierke", "Thomas Risberg", "Jon Brisbin",
            "Michael Hunger");
}

/**
 * Retrieve the number of pages per author (and divide the number of pages by the number of authors).
 */
@Test
public void shouldRetrievePagesPerAuthor() {

    Aggregation aggregation = newAggregation( //
            match(Criteria.where("volumeInfo.authors").exists(true)), //
            replaceRoot("volumeInfo"), //
            project("authors", "pageCount") //
                    .and(ArithmeticOperators.valueOf("pageCount") //
                            .divideBy(ArrayOperators.arrayOf("authors").length()))
                    .as("pagesPerAuthor"),
            unwind("authors"), //
            group("authors") //
                    .sum("pageCount").as("totalPageCount") //
                    .sum("pagesPerAuthor").as("approxWritten"), //
            sort(Direction.DESC, "totalPageCount"));

    AggregationResults<PagesPerAuthor> result = operations.aggregate(aggregation, "books", PagesPerAuthor.class);

    PagesPerAuthor pagesPerAuthor = result.getMappedResults().get(0);

    assertThat(pagesPerAuthor.getAuthor()).isEqualTo("Josh Long");
    assertThat(pagesPerAuthor.getTotalPageCount()).isEqualTo(1892);
    assertThat(pagesPerAuthor.getApproxWritten()).isEqualTo(573);
}

@RequestMapping("/center/fans")
@Menu(type = "apps" , subtype = "user" , name="fans" , access = false)
public ModelAndView centerfans(HttpServletRequest request , HttpServletResponse response, @Valid String orgi, @Valid String q) {
    ModelAndView view = request(super.createAppsTempletResponse("/apps/user/centerfans")) ;
    String userid = super.getUser(request).getId() ;
    Pageable page = new PageRequest(super.getP(request), super.getPs(request), new Sort(Direction.DESC, "createtime")) ;
    Page<Fans> fansList = fansRes.findByUser(userid, page) ;

    List<String> userids = new ArrayList<String>();
    for(Fans fan : fansList){
        userids.add(fan.getCreater()) ;
    }
    if(userids.size()>0){
        view.addObject("fansList",new PageImpl<User>(userRes.findAll(userids), page, fansList.getTotalElements()) ) ;
    }

    return view;
}

@RequestMapping("/center/follows")
@Menu(type = "apps" , subtype = "user" , name="follows" , access = false)
public ModelAndView centerfollows(HttpServletRequest request , HttpServletResponse response, @Valid String orgi, @Valid String q) {
    ModelAndView view = request(super.createAppsTempletResponse("/apps/user/centerfollows")) ;
    String userid = super.getUser(request).getId() ;
    Pageable page = new PageRequest(super.getP(request), super.getPs(request), new Sort(Direction.DESC, "createtime")) ;
    Page<Fans> fansList = fansRes.findByCreater(userid, page) ;

    List<String> userids = new ArrayList<String>();
    for(Fans fan : fansList){
        userids.add(fan.getUser()) ;
    }
    if(userids.size()>0){
        view.addObject("fansList",new PageImpl<User>(userRes.findAll(userids), page, fansList.getTotalElements()) ) ;
    }


    return view;
}

/**
 * Retorna a listagem de lançamentos de um funcionário.
 * 
 * @param funcionarioId
 * @return ResponseEntity<Response<LancamentoDto>>
 */
@GetMapping(value = "/funcionario/{funcionarioId}")
public ResponseEntity<Response<Page<LancamentoDto>>> listarPorFuncionarioId(
        @PathVariable("funcionarioId") Long funcionarioId,
        @RequestParam(value = "pag", defaultValue = "0") int pag,
        @RequestParam(value = "ord", defaultValue = "id") String ord,
        @RequestParam(value = "dir", defaultValue = "DESC") String dir) {
    log.info("Buscando lançamentos por ID do funcionário: {}, página: {}", funcionarioId, pag);
    Response<Page<LancamentoDto>> response = new Response<Page<LancamentoDto>>();

    PageRequest pageRequest = new PageRequest(pag, this.qtdPorPagina, Direction.valueOf(dir), ord);
    Page<Lancamento> lancamentos = this.lancamentoService.buscarPorFuncionarioId(funcionarioId, pageRequest);
    Page<LancamentoDto> lancamentosDto = lancamentos.map(lancamento -> this.converterLancamentoDto(lancamento));

    response.setData(lancamentosDto);
    return ResponseEntity.ok(response);
}

public Pageable getPageable(Map<String, String> requestParams) {
    int page = RequestUtil.getInteger(requestParams, "pageNum", 1) - 1;
    int size = RequestUtil.getInteger(requestParams, "pageSize", 10);
    String[] orders = RequestUtil.getArray(requestParams, "sortOrder");
    String[] sorts = RequestUtil.getArray(requestParams, "sortName");

    List<Order> sortOrders = new ArrayList<Order>();
    for (int i = 0; i < sorts.length; i++) {
        String sort = sorts[i];
        String order = orders[i];
        if (order.equals("asc")) {
            sortOrders.add(new Order(Direction.ASC, sort));
        } else if (order.equals("desc")) {
            sortOrders.add(new Order(Direction.DESC, sort));
        } else {
            throw new IllegalArgumentException("Value for param 'order' is not valid : '" + order + "', must be 'asc' or 'desc'");
        }
    }

    if (sortOrders.isEmpty()) {
        return new PageRequest(page, size);
    } else {
        return new PageRequest(page, size, new Sort(sortOrders));
    }
}

/**
 * Build and return a new {@link PageRequest} from the page information and ordering.
 * 
 * @param ormMapping
 *            The mapping from JSon name to ORM property or function.
 * @param parameters
 *            The available query parameters.
 * @param pageLength
 *            The resolved page length.
 * @param firstPage
 *            The page index.
 * @param column
 *            The sorted column name.
 * @param caseSensitiveColumns
 *            Optional JSon columns name where the case sensitive ordering is requested. The "lower" function will
 *            not be
 *            used for the "ORDER BY" in this case.
 * @return The new {@link PageRequest} with pagination and order.
 */
@NotNull
private PageRequest newSortedPageRequest(final Map<String, String> ormMapping, final MultivaluedMap<String, String> parameters,
        final int pageLength, final int firstPage, final String column, final Collection<String> caseSensitiveColumns) {
    final String direction = getSortDirection(parameters);
    final PageRequest pageRequest;
    final String ormProperty = getOrmColumn(ormMapping, column);
    if (ormProperty == null) {
        // Not enough information for build an ORDER BY
        pageRequest = PageRequest.of(firstPage, pageLength);
    } else {
        // Ordering query can be built
        final Sort sort;
        if ((caseSensitiveColumns == null || !caseSensitiveColumns.contains(column)) && ormProperty.indexOf('(') == -1) {
            if (ormProperty.indexOf('.') == -1) {
                sort = Sort.by(new Sort.Order(Direction.valueOf(direction.toUpperCase(Locale.ENGLISH)), ormProperty).ignoreCase());
            } else {
                sort = JpaSort.unsafe(Direction.valueOf(direction.toUpperCase(Locale.ENGLISH)), "UPPER(" + ormProperty + ")");
            }
        } else {
            sort = JpaSort.unsafe(Direction.valueOf(direction.toUpperCase(Locale.ENGLISH)), ormProperty);
        }
        pageRequest = PageRequest.of(firstPage, pageLength, sort);
    }
    return pageRequest;
}

/**
 * Default find all, empty rules, with sorting on a mapped column.
 */
@Test
public void testFindAllWithSorting2() {
    final UiPageRequest uiPageRequest = new UiPageRequest();
    uiPageRequest.setUiSort(new UiSort());
    uiPageRequest.getUiSort().setColumn("any");
    uiPageRequest.getUiSort().setDirection(Direction.DESC);
    uiPageRequest.setPageSize(10);
    final Map<String, String> mapping = new HashMap<>();
    mapping.put("any", "dialLong");
    final Page<SystemDialect> findAll = paginationDao.findAll(SystemDialect.class, uiPageRequest, mapping, null, null);
    Assert.assertTrue(findAll.hasContent());
    Assert.assertEquals(10, findAll.getSize());
    Assert.assertEquals(COUNT, findAll.getTotalElements());
    Assert.assertEquals(COUNT / 10, findAll.getTotalPages());
    Assert.assertEquals(10, findAll.getContent().size());
    Assert.assertEquals(Long.valueOf(COUNT - 1), findAll.getContent().get(0).getDialLong());
}

/**
 * Sorted direction with ordering and corresponding ORM column.
 */
@Test
public void getPageRequestFullOrdering() {
    // 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", "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());
}

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

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

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

/**
 * Sorted columns with direction.
 */
@Test
public void getPageRequestSortedColumnWithFunction() {
    // 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", "COUNT(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("COUNT(colOrm)"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("COUNT(colOrm)").getDirection());
    Assert.assertFalse(pageRequest.getSort().getOrderFor("COUNT(colOrm)").isIgnoreCase());
    Assert.assertEquals(100, pageRequest.getPageSize());
}

/**
 * Sorted columns with direction.
 */
@Test
public void getPageRequestCaseSensitiveOder() {
    // 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 PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, Collections.singletonMap("col1", "colOrm"),
            Collections.singleton("col1"));
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    Assert.assertNotNull(pageRequest.getSort().getOrderFor("colOrm"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("colOrm").getDirection());
    Assert.assertFalse(pageRequest.getSort().getOrderFor("colOrm").isIgnoreCase());
    Assert.assertEquals(100, pageRequest.getPageSize());
}

/**
 * Sorted columns with direction.
 */
@Test
public void getPageRequestCaseInsensitiveOder() {
    // 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 PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, Collections.singletonMap("col1", "colOrm"),
            Collections.singleton("any"));
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    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());
}

/**
 * Sorted columns with direction.
 */
@Test
public void getPageRequestCaseInsensitiveOderAlias() {
    // 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 PageRequest pageRequest = paginationJson.getPageRequest(uriInfo, Collections.singletonMap("col1", "c.colOrm"),
            Collections.singleton("any"));
    Assert.assertNotNull(pageRequest);
    Assert.assertNotNull(pageRequest.getSort());
    Assert.assertEquals(0, pageRequest.getOffset());
    Assert.assertEquals(0, pageRequest.getPageNumber());
    Assert.assertNotNull(pageRequest.getSort().getOrderFor("UPPER(c.colOrm)"));
    Assert.assertEquals(Direction.ASC, pageRequest.getSort().getOrderFor("UPPER(c.colOrm)").getDirection());
    Assert.assertEquals(100, pageRequest.getPageSize());
}

/**
 * Simple page request with default values but sorted column.
 */
@Test
public void getUiPageRequestSimpleSortDesc() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add("page", "1");
    uriInfo.getQueryParameters().add("rows", String.valueOf(PaginationJson.DEFAULT_PAGE_SIZE));
    uriInfo.getQueryParameters().add("sord", "desc");
    uriInfo.getQueryParameters().add("sidx", "colX");
    final UiPageRequest pageRequest = paginationJson.getUiPageRequest(uriInfo);
    Assert.assertNotNull(pageRequest);
    Assert.assertEquals(1, pageRequest.getPage());
    Assert.assertEquals(10, pageRequest.getPageSize());
    Assert.assertNotNull(pageRequest.getUiFilter());
    Assert.assertNull(pageRequest.getUiFilter().getGroupOp());
    Assert.assertNull(pageRequest.getUiFilter().getRules());
    Assert.assertNotNull(pageRequest.getUiSort());
    Assert.assertEquals("colX", pageRequest.getUiSort().getColumn());
    Assert.assertEquals(Direction.DESC, pageRequest.getUiSort().getDirection());
}

/**
 * Simple page request with default values but sorted column.
 */
@Test
public void getUiPageRequestSimpleSort() {
    // create a mock URI info with pagination informations
    final UriInfo uriInfo = newUriInfo();
    uriInfo.getQueryParameters().add("sidx", "colX");
    final UiPageRequest pageRequest = paginationJson.getUiPageRequest(uriInfo);
    Assert.assertNotNull(pageRequest);
    Assert.assertEquals(1, pageRequest.getPage());
    Assert.assertEquals(10, pageRequest.getPageSize());
    Assert.assertNotNull(pageRequest.getUiFilter());
    Assert.assertNull(pageRequest.getUiFilter().getGroupOp());
    Assert.assertNull(pageRequest.getUiFilter().getRules());
    Assert.assertNotNull(pageRequest.getUiSort());
    Assert.assertEquals("colX", pageRequest.getUiSort().getColumn());
    Assert.assertEquals(Direction.ASC, pageRequest.getUiSort().getDirection());
}

@Test
public void testFindByFieldsInExample() {
    List<Book> booksFromRepository = bookRepository.findByTitle(books.get(0).getTitle());
    assertTrue(CollectionUtils.isNotEmpty(booksFromRepository));
    assertEquals(books.get(0), booksFromRepository.get(0));
    booksFromRepository.clear();

    booksFromRepository = bookRepository.findByGenre(books.get(0).getGenre(), new Sort(Direction.DESC, "pages"));
    assertTrue(CollectionUtils.isNotEmpty(booksFromRepository));
    assertEquals(3, booksFromRepository.size());
    assertEquals(books.get(1), booksFromRepository.get(0));
    booksFromRepository.clear();

    booksFromRepository = bookRepository.findByGenreAndPages(books.get(0).getGenre(), books.get(0).getPages());
    assertTrue(CollectionUtils.isNotEmpty(booksFromRepository));
    assertEquals(books.get(0), booksFromRepository.get(0));

    booksFromRepository = bookRepository.findByGenre(books.get(0).getGenre(), new PageRequest(0, 2));
    assertTrue(CollectionUtils.isNotEmpty(booksFromRepository));
    assertEquals(2, booksFromRepository.size());

}

@Override
public List<String> findTagsByPattern(Pattern pattern, int limit) {
    final Aggregation agg = newAggregation(
            project("meta.tags"),
            unwind("tags"),
            group("tags").count().as("count"),
            project("count").and("tags").previousOperation(),
            match(where("tags").regex(pattern)),
            sort(Direction.ASC, "tags"),
            limit(limit));

    final AggregationResults<DBObject> results = mongoTemplate.aggregate(agg, Conversation.class, DBObject.class);
    return results.getMappedResults()
            .stream()
            .map(i -> (String) i.get("tags"))
            .collect(Collectors.toList());
}

@Override
public List<Pair<String, Long>> findTags(long limit, long offset) {
    final Aggregation agg = newAggregation(
            project("meta.tags"),
            unwind("tags"),
            group("tags").count().as("count"),
            project("count").and("tags").previousOperation(),
            sort(Direction.DESC, "count"),
            skip(offset),
            limit(limit));

    final AggregationResults<DBObject> results = mongoTemplate.aggregate(agg, Conversation.class, DBObject.class);
    return results.getMappedResults()
            .stream()
            .map(i -> new ImmutablePair<>((String) i.get("tags"), (long) i.get("count")))
            .collect(Collectors.toList());
}

public <T> Pageable toSpringDataPageable(
        PaginacioParamsDto dto,
        Map<String, String> mapeigPropietatsOrdenacio) {
    List<Order> orders = new ArrayList<Order>();
    if (dto.getOrdres() != null) {
        for (OrdreDto ordre: dto.getOrdres()) {
            Direction direccio = OrdreDireccioDto.DESCENDENT.equals(ordre.getDireccio()) ? Sort.Direction.DESC : Sort.Direction.ASC;
            String propietat = ordre.getCamp();
            if (mapeigPropietatsOrdenacio != null) {
                String mapeig = mapeigPropietatsOrdenacio.get(ordre.getCamp());
                if (mapeig != null)
                    propietat = mapeig;
            } else {
                propietat = ordre.getCamp();
            }
            orders.add(new Order(
                    direccio,
                    propietat));
        }
    }
    return new PageRequest(
            dto.getPaginaNum(),
            dto.getPaginaTamany(),
            new Sort(orders));
}

@Transactional(readOnly = true)
public List<MobileHarvestDTO> getHarvests(
        final int firstCalendarYearOfHuntingYear, @Nonnull final HarvestSpecVersion harvestSpecVersion) {

    Objects.requireNonNull(harvestSpecVersion, "harvestSpecVersion must not be null");

    final Person person = activeUserService.requireActivePerson();

    // Harvest-specific authorization built into query
    final List<Harvest> harvests = harvestRepository.findAll(
            where(shooter(person))
                    .and(harvestsByHuntingYear(firstCalendarYearOfHuntingYear)),
            temporalSort(Direction.ASC));

    return harvestDtoTransformer.apply(harvests, harvestSpecVersion);
}

@Transactional(readOnly = true)
public List<MobileObservationDTO> getObservations(
        final int firstCalendarYearOfHuntingYear, @Nonnull final ObservationSpecVersion observationSpecVersion) {

    Objects.requireNonNull(observationSpecVersion, "observationSpecVersion must not be null");

    final Person person = activeUserService.requireActivePerson();

    // Observation-specific authorization built into query
    final List<Observation> observations = observationRepository.findAll(
            where(observer(person))
                    .and(observationsByHuntingYear(firstCalendarYearOfHuntingYear)),
            temporalSort(Direction.ASC));

    return observationDtoTransformer.apply(observations, observationSpecVersion);
}

/**
 * Retorna os Veiculos de acordo com o filtro.
 * 
 * @param placa
 *            Número da Placa do Veiculo. Busca com like à direita.
 * @return todos os Veiculos do Usuário paginado de 10 em 10.
 */
@RequestMapping(value = "/pesquisar", method = RequestMethod.GET)
@ApiOperation(value = "Pesquisa de Veículo")
public ResponseEntity<Page<Veiculo>> pesquisar(
        @RequestParam(name = "placa", required = true) String placa, 
        @PageableDefault(sort = { "placa" }, direction = Direction.ASC) Pageable pageable) {

    // Não permite caracteres especiais na busca
    Validate.isTrue(StringUtils.isAlphanumeric(placa));

    Predicate predicate = QVeiculo.veiculo.placa.like(placa.toUpperCase() + '%');

    Page<Veiculo> page = veiculoRepository.findAll(predicate, pageable);

    page.forEach(v -> v.getProprietario().getId()); // TODO buscar uma
                                                    // forma de arrumar
                                                    // no
                                                    // QueryDslPredicateExecutor
    return new ResponseEntity<>(page, HttpStatus.OK);
}

@Override
public Map<String, Object> findAll(int pageNumber) {
    logger.debug("Finding all valueSets with paging");
    Sort sort = new Sort(new Order(Direction.ASC, "code"));
    PageRequest pageRequest = new PageRequest(pageNumber,
            VALUE_SET_PAGE_SIZE, sort);

    Page<ValueSet> valueSets = valueSetRepository.findAll(pageRequest);

    Map<String, Object> pageResultsMap = new HashMap<String, Object>();
    pageResultsMap.put("valueSets",
            setDeletableToValueSetDto((valueSets.getContent())));
    pageResultsMap.put("totalNumberOfValueSets",
            valueSets.getTotalElements());
    pageResultsMap.put("totalPages", valueSets.getTotalPages());
    pageResultsMap.put("itemsPerPage", valueSets.getSize());
    pageResultsMap.put("currentPage", valueSets.getNumber());
    pageResultsMap.put("numberOfElements", valueSets.getNumberOfElements());

    return pageResultsMap;
}

@Override
public Map<String, Object> findAllByName(String searchTerm,
                                         String valueSetCategory, int pageNumber) {

    Sort sort = new Sort(new Order(Direction.ASC, "code"));
    PageRequest pageRequest = new PageRequest(pageNumber,
            VALUE_SET_PAGE_SIZE, sort);

    Page<ValueSet> pagedValueSets = valueSetRepository.findAllByNameLike(
            "%" + searchTerm + "%", "%" + valueSetCategory + "%",
            pageRequest);

    Map<String, Object> pageResultsMap = new HashMap<String, Object>();
    pageResultsMap.put("valueSets",
            setDeletableToValueSetDto(pagedValueSets.getContent()));
    pageResultsMap.put("totalNumberOfValueSets",
            pagedValueSets.getTotalElements());
    pageResultsMap.put("totalPages", pagedValueSets.getTotalPages());
    pageResultsMap.put("itemsPerPage", pagedValueSets.getSize());
    pageResultsMap.put("currentPage", pagedValueSets.getNumber());
    pageResultsMap.put("numberOfElements",
            pagedValueSets.getNumberOfElements());

    return pageResultsMap;

}

@Override
public Map<String, Object> findAllByCode(String searchTerm,
                                         String valueSetCategory, int pageNumber) {

    Sort sort = new Sort(new Order(Direction.ASC, "code"));
    PageRequest pageRequest = new PageRequest(pageNumber,
            VALUE_SET_PAGE_SIZE, sort);

    Page<ValueSet> pagedValueSets = valueSetRepository.findAllByCodeLike(
            "%" + searchTerm + "%", "%" + valueSetCategory + "%",
            pageRequest);

    Map<String, Object> pageResultsMap = new HashMap<String, Object>();
    pageResultsMap.put("valueSets",
            setDeletableToValueSetDto(pagedValueSets.getContent()));
    pageResultsMap.put("totalNumberOfValueSets",
            pagedValueSets.getTotalElements());
    pageResultsMap.put("totalPages", pagedValueSets.getTotalPages());
    pageResultsMap.put("itemsPerPage", pagedValueSets.getSize());
    pageResultsMap.put("currentPage", pagedValueSets.getNumber());
    pageResultsMap.put("numberOfElements",
            pagedValueSets.getNumberOfElements());

    return pageResultsMap;
}

@Override
@Transactional(readOnly = true)
public Map<String, Object> findAllConsentsDtoByPatientAndPage(Long patientId, String pageNumber) {
    final Patient patient = patientRepository.findOne(patientId);

    PageRequest page = new PageRequest(Integer.parseInt(pageNumber), 5,
            Direction.DESC, "startDate");


    final Page<Consent> pages = consentRepository.findByPatient(patient, page);
    List<ConsentListDto> consentListDtos = makeConsentListDtos();
    if (pages != null) {
        consentListDtos = consentListToConsentListDtosConverter(pages.getContent());
    }

    Map<String, Object> pageResultsMap = new HashMap<String, Object>();
    pageResultsMap.put("results", consentListDtos);
    pageResultsMap.put("totalItems", pages.getTotalElements());
    pageResultsMap.put("totalPages", pages.getTotalPages());
    pageResultsMap.put("itemsPerPage", pages.getSize());
    pageResultsMap.put("currentPage", pages.getNumber());

    return pageResultsMap;
}

@Test
public void executesQueryMethodsCorrectly() {
    City city = this.cityRepository
            .findAll(new PageRequest(0, 1, Direction.ASC, "name")).getContent()
            .get(0);
    assertThat(city.getName()).isEqualTo("Atlanta");

    Page<HotelSummary> hotels = this.repository.findByCity(city,
            new PageRequest(0, 10, Direction.ASC, "name"));
    Hotel hotel = this.repository.findByCityAndName(city,
            hotels.getContent().get(0).getName());
    assertThat(hotel.getName()).isEqualTo("Doubletree");

    List<RatingCount> counts = this.repository.findRatingCounts(hotel);
    assertThat(counts).hasSize(1);
    assertThat(counts.get(0).getRating()).isEqualTo(Rating.AVERAGE);
    assertThat(counts.get(0).getCount()).isGreaterThan(1L);
}

@Test
public void executesQueryMethodsCorrectly() {
    City city = this.cityRepository
            .findAll(new PageRequest(0, 1, Direction.ASC, "name")).getContent()
            .get(0);
    assertThat(city.getName()).isEqualTo("Atlanta");

    Page<HotelSummary> hotels = this.repository.findByCity(city,
            new PageRequest(0, 10, Direction.ASC, "name"));
    Hotel hotel = this.repository.findByCityAndName(city,
            hotels.getContent().get(0).getName());
    assertThat(hotel.getName()).isEqualTo("Doubletree");

    List<RatingCount> counts = this.repository.findRatingCounts(hotel);
    assertThat(counts).hasSize(1);
    assertThat(counts.get(0).getRating()).isEqualTo(Rating.AVERAGE);
    assertThat(counts.get(0).getCount()).isGreaterThan(1L);
}