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

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

protected String orderByExpression(Sort sort) {
    final String noSort = "";

    if (sort == null || !sort.iterator().hasNext()) {
        return noSort;
    }
    StringBuilder sb = new StringBuilder(" ORDER BY ");

    for (Iterator<Order> it = sort.iterator(); it.hasNext(); ) {
        Order order = it.next();
        sb.append(order.getProperty()).append(' ').append(order.getDirection());
        if (it.hasNext()) {
            sb.append(COMMA);
        }
    }
    return sb.toString();
}

/**
 * 方法名 ： 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;
}

@Test
public void getActiveUserStoriesByProjectNameTest() {

    DashboardDTO dashboard = TestObjectFactory.createDashboard();

    Feature story1 = TestObjectFactory.createActiveStory();
    Feature story2 = TestObjectFactory.createActiveStory();

    List<Feature> stories = new ArrayList<>();
    stories.add(story1);
    stories.add(story2);

    when(featureRepository.findActiveUserStoriesByBoards(Arrays.asList(dashboard.getName()),
            new Sort(new Order("sStatus")))).thenReturn(stories);

    List<Feature> activeStoriesByDashboardName
            = featureService.getActiveUserStoriesByBoards(Arrays.asList(dashboard.getName()));
    verify(featureRepository, times(1))
            .findActiveUserStoriesByBoards(Arrays.asList(dashboard.getName()), new Sort(new Order("sStatus")));

    assertThat(activeStoriesByDashboardName.get(0)).isEqualTo(story1);
    assertThat(activeStoriesByDashboardName.get(1)).isEqualTo(story2);
}

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

private <T, F> Sort createSpringSort(Query<T, F> q) {
    List<QuerySortOrder> sortOrders;
    if (q.getSortOrders().isEmpty()) {
        sortOrders = getDefaultSortOrders();
    } else {
        sortOrders = q.getSortOrders();
    }
    List<Order> orders = sortOrders.stream()
            .map(PageableDataProvider::queryOrderToSpringOrder)
            .collect(Collectors.toList());
    if (orders.isEmpty()) {
        return null;
    } else {
        return new Sort(orders);
    }
}

@Override
public SortOptions apply(Query<?> query) {
    SortOptions.Builder sortOptions = SortOptions.newBuilder();

    query.getSort().ifPresent(sort -> {
        for (Order order : sort) {
            SearchFieldMetadata searchFieldMetadata = searchMetadata.getField(query.getResultType(), order.getProperty());

            SortExpression.Builder expression = SortExpression.newBuilder()
                    .setExpression(searchFieldMetadata.getEncodedName())
                    .setDirection(order.getDirection().isAscending() ? ASCENDING : DESCENDING);

            applyDefaultValue(order, searchFieldMetadata.getIndexType(), expression);

            sortOptions.addSortExpression(expression.build());
        }
    });

    return sortOptions.build();
}

@Test
public void should_sort_health_responses() {
    // GIVEN
    Sort sort = new Sort(
            new Order(ASC, "status"),
            new Order(DESC, "totalTimeMillis"),
            new Order(ASC, "service")
    );

    // WHEN
    Comparator<HealthResponse> comparator = sortCompare.getComparator(sort);
    List<HealthResponse> sorted = ImmutableList.sortedCopyOf(comparator, givenHealthResponses());

    // THEN
    then(sorted).extracting(HealthResponse::getService).containsExactly("E", "D", "C", "B", "A");
}

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

private <T, F> Sort createSpringSort(Query<T, F> q) {
    List<QuerySortOrder> sortOrders;
    if (q.getSortOrders().isEmpty()) {
        sortOrders = getDefaultSortOrders();
    } else {
        sortOrders = q.getSortOrders();
    }
    List<Order> orders = sortOrders.stream()
            .map(PageableDataProvider::queryOrderToSpringOrder)
            .collect(Collectors.toList());
    if (orders.isEmpty()) {
        return null;
    } else {
        return new Sort(orders);
    }
}

private Query<T> sortQuery(Query<T> query, Sort sort){
    if (sort == null){
        return query;
    }

    Order order;
    for (Iterator<Order> iter=sort.iterator(); iter.hasNext(); ){
        order=iter.next();
        String condition = order.getProperty();
        if (order.getDirection().isDescending()){
            condition = "-" + condition;
        }
        query = query.order(condition);
    }

    return query;
}

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

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

@Test
public void findAllByAscendingSort() throws Exception {
    // given
    dbSetupTracker.skipNextLaunch();

    // when
    List<BookApi> bookApis = repository.findAll(new Sort(new Order(Sort.Direction.ASC, "id")));

    // then
    assertThat(bookApis)
        .isNotNull()
        .isNotEmpty()
        .hasSize(3)
        .extracting("id", "name", "url")
        .containsExactly(
            tuple(1, "Amazon Product Advertising API", "https://ecs.amazonaws.jp/onca/xml"),
            tuple(2, "Google Books API", "https://www.googleapis.com/books/v1/volumes"),
            tuple(3, "楽天ブックス書籍検索API", "https://app.rakuten.co.jp/services/api/BooksBook/Search/20130522")
        );
}

@Test
public void findAllByDescendingSort() throws Exception {
    // given
    dbSetupTracker.skipNextLaunch();

    // when
    List<BookApi> bookApis = repository.findAll(new Sort(new Order(Sort.Direction.DESC, "id")));

    // then
    assertThat(bookApis)
        .isNotNull()
        .isNotEmpty()
        .hasSize(3)
        .extracting("id", "name", "url")
        .containsExactly(
            tuple(3, "楽天ブックス書籍検索API", "https://app.rakuten.co.jp/services/api/BooksBook/Search/20130522"),
            tuple(2, "Google Books API", "https://www.googleapis.com/books/v1/volumes"),
            tuple(1, "Amazon Product Advertising API", "https://ecs.amazonaws.jp/onca/xml")
        );
}

/**
 * Returns a full ordering criteria from the datatables parameters.
 * @return the ordering criteria
 */
public DatatablesSort getSort() {
  int columnCount = getColumnCount();

  if (columnCount <= 0) {
    return null;
  }

  List<Order> orderList = new ArrayList<Order>(columnCount);

  for (int i = 0; i < columnCount; i++) {
    Order order = getOrderInPosition(i);
    if (order != null) {
      orderList.add(order);
    }
  }

  if (orderList.isEmpty()) {
    return null;
  }

  return new DatatablesSort(orderList);
}

@Test
public void orderLoadedFromPosition() {
  // Prepare: ordering first with property3 and then with property1
  parser = createParser(
      new String[] {"order[0][column]", "order[1][column]", "order[0][dir]", "order[1][dir]",
          "columns[0][data]", "columns[1][data]", "columns[2][data]", "columns[3][data]"},
      new String[] {"3", "1", "asc", "desc", "property0", "property1", "property2", "property3"});

  // Exercise
  Order order0 = parser.getOrderInPosition(0);
  Order order1 = parser.getOrderInPosition(1);

  // Verify
  assertThat(order0.getProperty()).as("Nombre de propiedad ordenada correcta")
      .isEqualTo("property3");
  assertThat(order0.getDirection()).as("Dirección de ordenación de propiedad correcta")
      .isEqualTo(Direction.ASC);
  assertThat(order1.getProperty()).as("Nombre de propiedad ordenada correcta")
      .isEqualTo("property1");
  assertThat(order1.getDirection()).as("Dirección de ordenación de propiedad correcta")
      .isEqualTo(Direction.DESC);
}

@Test
public void validSortParsed() {
  // Prepare: ordering first with property3 and then with property1
  parser = createParser(
      new String[] {"order[0][column]", "order[1][column]", "order[0][dir]", "order[1][dir]",
          "columns[0][data]", "columns[1][data]", "columns[2][data]", "columns[3][data]"},
      new String[] {"3", "1", "asc", "desc", "property0", "property1", "property2", "property3"});

  // Exercise
  Sort sort = parser.getSort();
  Order order0 = sort.getOrderFor("property3");
  Order order1 = sort.getOrderFor("property1");

  // Verify
  assertThat(order0.getProperty()).as("Nombre de propiedad ordenada correcta")
      .isEqualTo("property3");
  assertThat(order0.getDirection()).as("Dirección de ordenación de propiedad correcta")
      .isEqualTo(Direction.ASC);
  assertThat(order1.getProperty()).as("Nombre de propiedad ordenada correcta")
      .isEqualTo("property1");
  assertThat(order1.getDirection()).as("Dirección de ordenación de propiedad correcta")
      .isEqualTo(Direction.DESC);
}

public static Sort covertSortDto(SortDto sortDto) {

        if (sortDto == null || sortDto.getOrders() == null
                || sortDto.getOrders().isEmpty()) {
            return null;
        }
        List<Order> orders = new ArrayList<>();

        for (OrderDto orderdto : sortDto.getOrders()) {
            Order order = new Order(Sort.Direction.fromString(orderdto
                    .getDirection().name()), orderdto.getProperty());
            if (orderdto.isIgnoreCase()) {
                order = order.ignoreCase();
            }
            orders.add(order);
        }

        return new Sort(orders);
    }

public static Pageable createPageable(ExtDirectStoreReadRequest request) {

        List<Order> orders = new ArrayList<>();
        for (SortInfo sortInfo : request.getSorters()) {

            if (sortInfo.getDirection() == SortDirection.ASCENDING) {
                orders.add(new Order(Direction.ASC, sortInfo.getProperty()));
            }
            else {
                orders.add(new Order(Direction.DESC, sortInfo.getProperty()));
            }
        }

        // Ext JS pages starts with 1, Spring Data starts with 0
        int page = Math.max(request.getPage() - 1, 0);

        if (orders.isEmpty()) {
            return new PageRequest(page, request.getLimit());
        }

        Sort sort = new Sort(orders);
        return new PageRequest(page, request.getLimit(), sort);

    }

/**
 * SEARCH /_search/meetings/:query -> search for the meeting corresponding
 * to the query.
 */

@RequestMapping(value = "/_search/meetings/{query}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public List<MeetingDTO> search(@PathVariable
String query) {

    log.info(query + "*");
    List<Sort.Order> orders = new ArrayList<>();
    orders.add(new Order(Sort.Direction.DESC, "startDate"));
    Sort sort = new Sort(orders);
    NativeSearchQuery q = new NativeSearchQuery(queryStringQuery(query + "*"));
    q.addSort(sort);
    Pageable pageable = new PageRequest(0, 10000);
    q.setPageable(pageable);
    return StreamSupport.stream(meetingSearchRepository.search(q).spliterator(), false)
            .map(meetingMapper::meetingToMeetingDTO).collect(Collectors.toList());
}

public static Pageable createPageable(ExtDirectStoreReadRequest request) {

        List<Order> orders = new ArrayList<>();
        for (SortInfo sortInfo : request.getSorters()) {

            if (sortInfo.getDirection() == SortDirection.ASCENDING) {
                orders.add(new Order(Direction.ASC, sortInfo.getProperty()));
            }
            else {
                orders.add(new Order(Direction.DESC, sortInfo.getProperty()));
            }
        }

        // Ext JS pages starts with 1, Spring Data starts with 0
        int page = Math.max(request.getPage() - 1, 0);

        if (orders.isEmpty()) {
            return new PageRequest(page, request.getLimit());
        }

        Sort sort = new Sort(orders);
        return new PageRequest(page, request.getLimit(), sort);

    }

@Test
public void testSort_Order() throws Exception {
    Hessian2Serialization.addSerializer(Sort.Order.class, new OrderSerializer());
    Hessian2Serialization.addDeserializer(Sort.Order.class, new OrderDeserializer());

    final Sort.Order[] orders = new Sort.Order[3];
    orders[0] = new Sort.Order(Sort.Direction.ASC, "order_num", null);
    orders[1] = new Sort.Order(null, "order_num", null);
    orders[2] = new Sort.Order(Sort.Direction.DESC, "create_time", NullHandling.NULLS_LAST);

    final byte[] buf = Hessian2Serialization.serialize(orders);

    //      System.out.println(new String(buf));

    final Sort.Order[] expectOrders = Hessian2Serialization.deserialize(buf);

    for (int i = 0; i < orders.length; i++) {
        Assert.assertTrue(orders[i].equals(expectOrders[i]));
    }
}

@Test
public void testPageable() throws Exception {
    Hessian2Serialization.addSerializer(Sort.Order.class, new OrderSerializer());
    Hessian2Serialization.addDeserializer(Sort.Order.class, new OrderDeserializer());
    Hessian2Serialization.addSerializer(Sort.class, new SortSerializer());
    Hessian2Serialization.addDeserializer(Sort.class, new SortDeserializer());
    Hessian2Serialization.addSerializer(PageRequest.class, new PageableSerializer());
    Hessian2Serialization.addDeserializer(PageRequest.class, new PageableDeserializer(PageRequest.class));

    Pageable pageable;

    pageable = new PageRequest(0, 100, Direction.DESC, "order_num");

    Assert.assertEquals(pageable, Hessian2Serialization.deserialize(Hessian2Serialization.serialize(pageable)));

    pageable = new PageRequest(0, 100,
            new Sort(new Order(Direction.ASC, "order_num"), new Order(Direction.DESC, "update_time")));

    Assert.assertEquals(pageable, Hessian2Serialization.deserialize(Hessian2Serialization.serialize(pageable)));
}

/**
 * Parses the sort string e.g. given in a REST call based on the definition
 * of sorting: http://localhost/entity?s=field1:ASC, field2:DESC The fields
 * will be split into the keys of the returned map. The direction of the
 * sorting will be mapped into the {@link Direction} enum.
 * 
 * @param enumType
 *            the class of the enum which the fields in the sort string
 *            should be related to.
 * @param <T>
 *            the type of the enumeration which must be derived from
 *            {@link FieldNameProvider}
 * @param sortString
 *            the string representation of the query parameters. Might be
 *            {@code null} or an empty string.
 * @return a list which holds the {@link FieldNameProvider} and the specific
 *         {@link Direction} for them as a tuple. Never {@code null}. In
 *         case of no sorting parameters an empty map will be returned.
 * @throws SortParameterSyntaxErrorException
 *             if the sorting query parameter is not well-formed
 * @throws SortParameterUnsupportedFieldException
 *             if a field name cannot be mapped to the enum type
 * @throws SortParameterUnsupportedDirectionException
 *             if the given direction is not "ASC" or "DESC"
 */
public static <T extends Enum<T> & FieldNameProvider> List<Order> parse(final Class<T> enumType,
        final String sortString) throws SortParameterSyntaxErrorException {
    final List<Order> parsedSortings = new ArrayList<>();
    // scan the sort tuples e.g. field:direction
    if (sortString != null) {
        final StringTokenizer tupleTokenizer = new StringTokenizer(sortString, DELIMITER_SORT_TUPLE);
        while (tupleTokenizer.hasMoreTokens()) {
            final String sortTuple = tupleTokenizer.nextToken().trim();
            final StringTokenizer fieldDirectionTokenizer = new StringTokenizer(sortTuple,
                    DELIMITER_FIELD_DIRECTION);
            if (fieldDirectionTokenizer.countTokens() == 2) {
                final String fieldName = fieldDirectionTokenizer.nextToken().trim().toUpperCase();
                final String sortDirectionStr = fieldDirectionTokenizer.nextToken().trim();

                final T identifier = getAttributeIdentifierByName(enumType, fieldName);

                final Direction sortDirection = getDirection(sortDirectionStr);
                parsedSortings.add(new Order(sortDirection, identifier.getFieldName()));
            } else {
                throw new SortParameterSyntaxErrorException();
            }
        }
    }
    return parsedSortings;
}

public static Pageable createPageable(ExtDirectStoreReadRequest request) {

        List<Order> orders = new ArrayList<>();
        for (SortInfo sortInfo : request.getSorters()) {

            if (sortInfo.getDirection() == SortDirection.ASCENDING) {
                orders.add(new Order(Direction.ASC, sortInfo.getProperty()));
            }
            else {
                orders.add(new Order(Direction.DESC, sortInfo.getProperty()));
            }
        }

        // Ext JS pages starts with 1, Spring Data starts with 0
        int page = Math.max(request.getPage() - 1, 0);

        if (orders.isEmpty()) {
            return new PageRequest(page, request.getLimit());
        }

        Sort sort = new Sort(orders);
        return new PageRequest(page, request.getLimit(), sort);

    }

private Order[] loadDefaultOrder() {
    Order[] loadedOrder;

    DefaultOrder defaultOrderAnnotation = modelClass.getAnnotation(DefaultOrder.class);
    if (defaultOrderAnnotation != null && defaultOrderAnnotation.expression().length > 0) {
        org.demyo.model.util.DefaultOrder.Order[] defaultOrderExpression = defaultOrderAnnotation.expression();

        loadedOrder = new Order[defaultOrderExpression.length];

        // Convert the default order to expressions that can be handled later. Preserve the order of the annotation.
        for (int i = 0; i < defaultOrderExpression.length; i++) {
            org.demyo.model.util.DefaultOrder.Order order = defaultOrderExpression[i];
            loadedOrder[i] = new Order(order.asc() ? Direction.ASC : Direction.DESC, order.property());
        }
    } else {
        loadedOrder = null;
    }

    return loadedOrder;
}

/**
 * Creates an url to sort data by fieldName
 * 
 * @param context execution context
 * @param fieldName field name to sort
 * @return sort URL
 */
public static String createSortUrl(final ITemplateContext context, final String fieldName) {
    // Params can be prefixed to manage multiple pagination on the same page
    final String prefix = getParamPrefix(context);
    final Collection<String> excludedParams = Arrays
            .asList(new String[] { prefix.concat(SORT), prefix.concat(PAGE) });
    final String baseUrl = buildBaseUrl(context, excludedParams);

    final StringBuilder sortParam = new StringBuilder();
    final Page<?> page = findPage(context);
    final Sort sort = page.getSort();
    final boolean hasPreviousOrder = sort != null && sort.getOrderFor(fieldName) != null;
    if (hasPreviousOrder) {
        // Sort parameters exists for this field, modify direction
        Order previousOrder = sort.getOrderFor(fieldName);
        Direction dir = previousOrder.isAscending() ? Direction.DESC : Direction.ASC;
        sortParam.append(fieldName).append(COMMA).append(dir.toString().toLowerCase());
    } else {
        sortParam.append(fieldName);
    }

    return buildUrl(baseUrl, context).append(SORT).append(EQ).append(sortParam).toString();
}

@Override
public String build(TableEntity tab, HashMap<String, String> params, Pageable pageable, Sort sort) {

    Assert.notNull(tab, "TableEntity is null.");
    Assert.notNull(pageable, "Pageable is null.");
    Assert.notNull(sort, "Sort is null.");

    String limit = String.valueOf(pageable.getPageSize());
    int off = (pageable.getPageNumber() - 1) * pageable.getPageSize();
    String offset = String.valueOf(off);

    Iterator<Order> iterator = sort.iterator();
    Order order = iterator.next();

    return "SELECT * FROM " + tab.getName() + " ORDER BY " + order.getProperty()
            + " ASC" + " LIMIT " + limit + " OFFSET " + offset + ";";          
}

/**
 * Creates a new {@link OrderBySource} for the given clause, checking the property referenced exists on the given
 * type.
 * 
 * @param clause must not be {@literal null}.
 * @param domainClass can be {@literal null}.
 */
public GqOrderBySource(String clause, Class<?> domainClass) {

    this.orders = new ArrayList<Sort.Order>();

    for (String part : clause.split(BLOCK_SPLIT)) {

        Matcher matcher = DIRECTION_SPLIT.matcher(part);

        if (!matcher.find()) {
            throw new IllegalArgumentException(String.format(INVALID_ORDER_SYNTAX, part));
        }

        String propertyString = matcher.group(1);
        String directionString = matcher.group(2);

        // No property, but only a direction keyword
        if (DIRECTION_KEYWORDS.contains(propertyString) && directionString == null) {
            throw new IllegalArgumentException(String.format(INVALID_ORDER_SYNTAX, part));
        }

        Direction direction = StringUtils.hasText(directionString) ? Direction.fromString(directionString) : null;
        this.orders.add(createOrder(propertyString, direction, domainClass));
    }
}

private static Sort parseParameterIntoSort(String[] source) {
    if(source == null) return null;

    List<Order> allOrders = new ArrayList<Sort.Order>();
    for (String part : source) {
        if (part == null) {
            continue;
        }
        String[] elements = part.split(",");
        Direction direction = Direction.fromStringOrNull(elements[elements.length - 1]);
        for (int i = 0; i < elements.length; i++) {
            if (i == elements.length - 1 && direction != null) {
                continue;
            }
            allOrders.add(new Order(direction, elements[i]));
        }
    }
    return allOrders.isEmpty() ? null : new Sort(allOrders);
}

@Override
   public List<IAViewUpdate> findDocumentsCreatedFromDateAndCreatedBeforeDate(Date gtDate, Date ltDate, Integer limit) {
List<Criteria> listOfCriterias = new ArrayList<Criteria>();
if (gtDate != null) {
    listOfCriterias.add(Criteria.where(IAViewUpdate.FIELD_CREATIONDATE).gte(gtDate));
}
if (ltDate != null) {
    listOfCriterias.add(Criteria.where(IAViewUpdate.FIELD_CREATIONDATE).lt(ltDate));
}
Query query = new Query(new Criteria().andOperator(listOfCriterias.toArray(new Criteria[0])));

query.limit(limit + 1);
query.with(new Sort(new Order(Sort.Direction.ASC, IAViewUpdate.FIELD_CREATIONDATE), new Order(
    Sort.Direction.ASC, IAViewUpdate.FIELD_DOCREFERENCE)));
return mongoTemplate.find(query, IAViewUpdate.class);
   }

@Override
   public List<IAViewUpdate> findDocumentsCreatedAfterDocumentAndCreatedBeforeDate(IAViewUpdate afterIAViewUpdate,
    Date ltDate, Integer limit) {
List<Criteria> listOfCriterias = new ArrayList<Criteria>();
listOfCriterias.add(new Criteria().orOperator(
    Criteria.where(IAViewUpdate.FIELD_CREATIONDATE).gt(afterIAViewUpdate.getCreationDate()),
    new Criteria().andOperator(
        Criteria.where(IAViewUpdate.FIELD_CREATIONDATE).gte(afterIAViewUpdate.getCreationDate()),
        Criteria.where(IAViewUpdate.FIELD_DOCREFERENCE).gt(afterIAViewUpdate.getDocReference()))));
if (ltDate != null) {
    listOfCriterias.add(Criteria.where(IAViewUpdate.FIELD_CREATIONDATE).lt(ltDate));
}
Query query = new Query(new Criteria().andOperator(listOfCriterias.toArray(new Criteria[0])));

query.limit(limit + 1);
query.with(new Sort(new Order(Sort.Direction.ASC, IAViewUpdate.FIELD_CREATIONDATE), new Order(
    Sort.Direction.ASC, IAViewUpdate.FIELD_DOCREFERENCE)));
return mongoTemplate.find(query, IAViewUpdate.class);
   }

/**
 * Append sorting parameters to {@link SolrQuery}
 * 
 * @param solrQuery
 * @param sort
 */
@SuppressWarnings("deprecation")
protected void appendSort(SolrQuery solrQuery, Sort sort) {
    if (sort == null) {
        return;
    }

    for (Order order : sort) {
        // addSort which is to be used instead of addSortField is not available in versions below 4.2.0
        if (VersionUtil.isSolr420Available()) {
            solrQuery.addSort(order.getProperty(), order.isAscending() ? ORDER.asc : ORDER.desc);
        } else {
            solrQuery.addSortField(order.getProperty(), order.isAscending() ? ORDER.asc : ORDER.desc);
        }
    }
}

@Test
public void testSetPageRequestWithSort() {
    SimpleQuery query = new SimpleQuery();

    Pageable alteredPage = new PageRequest(0, 20, Sort.Direction.DESC, "value_1", "value_2");

    query.setPageRequest(alteredPage);
    Assert.assertThat(query.getPageRequest(), IsEqual.equalTo(alteredPage));
    Assert.assertNotNull(query.getSort());

    int i = 0;
    for (Order order : query.getSort()) {
        Assert.assertEquals(Sort.Direction.DESC, order.getDirection());
        Assert.assertEquals("value_" + (++i), order.getProperty());
    }
}

/**
 * Method converts object {@link org.springframework.data.domain.Sort} into {@link pl.edu.icm.saos.search.search.model.Sorting}.
 * If Sort object contains incorrect value of sort field, method returns sorting by relevance. 
 * 
 * @param sort {@link org.springframework.data.domain.Sort} 
 * @return {@link pl.edu.icm.saos.search.search.model.Sorting}
 */
public Sorting convert(Sort sort) {
    Iterator<Order> order = sort.iterator();

    // Get one sorting property, if it is not valid use sorting by relevance.
    if (order.hasNext()) {
        Order next = order.next(); 
        String property = next.getProperty();

        if (JudgmentIndexField.hasFieldName(property)) {
            return new Sorting(JudgmentIndexField.valueOf(property).getFieldName(), convertDirection(next.getDirection()));
        }

           return Sorting.relevanceSorting(convertDirection(next.getDirection()));
    } 

    return Sorting.relevanceSorting();
}

/**
 * Transforms a plain {@link Order} into a QueryDsl specific {@link OrderSpecifier}.
 *
 * @param sort must not be {@literal null}.
 * @param builder must not be {@literal null}.
 * @return empty {@code OrderSpecifier<?>[]} when sort is {@literal null}.
 */
static OrderSpecifier<?>[] toOrderSpecifier(Sort sort, PathBuilder<?> builder) {

    Assert.notNull(sort, "Sort must not be null.");
    Assert.notNull(builder, "Builder must not be null.");

    List<OrderSpecifier<?>> specifiers = null;

    if (sort instanceof QSort) {
        specifiers = ((QSort) sort).getOrderSpecifiers();
    } else {

        specifiers = new ArrayList<>();
        for (Order order : sort) {
            specifiers.add(toOrderSpecifier(order, builder));
        }
    }

    return specifiers.toArray(new OrderSpecifier<?>[specifiers.size()]);
}

/**
 * Creates an {@link Expression} for the given {@link Order} property.
 *
 * @param order must not be {@literal null}.
 * @param builder must not be {@literal null}.
 * @return
 */
private static Expression<?> buildOrderPropertyPathFrom(Order order, PathBuilder<?> builder) {

    Assert.notNull(order, "Order must not be null!");
    Assert.notNull(builder, "Builder must not be null!");

    PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
    Expression<?> sortPropertyExpression = builder;

    while (path != null) {

        if (!path.hasNext() && order.isIgnoreCase()) {
            // if order is ignore-case we have to treat the last path segment as a String.
            sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
        } else {
            sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
        }

        path = path.next();
    }

    return sortPropertyExpression;
}