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