/** * 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 */ public OrderBySource(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 for part %s!", part)); } Direction direction = Direction.fromString(matcher.group(2)); this.orders.add(createOrder(matcher.group(1), direction, domainClass)); } }
public static Sort buildSort(List<String> fields, List<String> directions){ List<Order> result = new LinkedList<>(); for (int i = 0; i < fields.size(); i++) { if(directions.get(i) == null){ result.add(new Order(fields.get(i))); } else{ result.add(new Order(Direction.fromString(directions.get(i)), fields.get(i))); } } return new Sort(result); } }
/** * Returns the {@link Direction} enum for the given {@link String} or null if it cannot be parsed into an enum * value. * * @param value * @return */ public static Optional<Direction> fromOptionalString(String value) { try { return Optional.of(fromString(value)); } catch (IllegalArgumentException e) { return Optional.empty(); } } }
@Override public Pageable deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonNode node = jp.getCodec().readTree(jp); Sort sort = null; int pageNumber = node.get(PROPERTY_PAGE_NUMBER).asInt(); int pageSize = node.get(PROPERTY_PAGE_SIZE).asInt(); JsonNode sortNode = node.get(PROPERTY_SORT); if ((sortNode != null) && !sortNode.isNull() && sortNode.isArray()) { Iterator<JsonNode> iterator = sortNode.iterator(); List<Order> sortingOrders = new ArrayList<>(); while (iterator.hasNext()) { JsonNode next = iterator.next(); String property = getRequiredValue(next, PROPERTY_PROPERTY); String direction = getRequiredValue(next, PROPERTY_DIRECTION); sortingOrders.add(new Order(Direction.fromString(direction), property)); } sort = Sort.by(sortingOrders); } return PageRequest.of(pageNumber, pageSize, sort); }
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); } }
/** * {@inheritDoc} */ @Override public Page<T> findPaginated(@RequestParam(value = "page", required = false, defaultValue = "1") Integer page, @RequestParam(value = "size", required = false, defaultValue = "10") Integer size, @RequestParam(value = "direction", required = false, defaultValue = "") String direction, @RequestParam(value = "properties", required = false) String properties) { Assert.isTrue(page > 0, "Page index must be greater than 0"); Assert.isTrue(direction.isEmpty() || direction.equalsIgnoreCase(Sort.Direction.ASC.toString()) || direction.equalsIgnoreCase(Sort.Direction.DESC.toString()), "Direction should be ASC or DESC"); if (direction.isEmpty()) { return this.service.findAll(new PageRequest(page - 1, size)); } else { Assert.notNull(properties); return this.service.findAll(new PageRequest(page - 1, size, new Sort(Sort.Direction.fromString(direction.toUpperCase()), properties.split(",")))); } }
/** * {@inheritDoc} */ @Override public Page<T> findPaginated(@RequestParam(value = "page", required = false, defaultValue = "1") Integer page, @RequestParam(value = "size", required = false, defaultValue = "10") Integer size, @RequestParam(value = "direction", required = false, defaultValue = "") String direction, @RequestParam(value = "properties", required = false) String properties) { Assert.isTrue(page > 0, "Page index must be greater than 0"); Assert.isTrue(direction.isEmpty() || direction.equalsIgnoreCase(Sort.Direction.ASC.toString()) || direction.equalsIgnoreCase(Sort.Direction.DESC.toString()), "Direction should be ASC or DESC"); if(direction.isEmpty()) { return this.repository.findAll(new PageRequest(page - 1, size)); } else { Assert.notNull(properties); return this.repository.findAll(new PageRequest(page - 1, size, new Sort(Sort.Direction.fromString(direction.toUpperCase()), properties.split(",")))); } }
public static Sort basicSort(String orderType, String orderField) { Sort sort = new Sort(Sort.Direction.fromString(orderType), orderField); return sort; }
private Sort parseParameterIntoSort(final String sortParameterValue, final String sortDirParameterValue, final NativeWebRequest webRequest) { final String columnName = SearchFilterUtils.translateSortProperty(getListName(webRequest), sortParameterValue); final Direction order = null == sortDirParameterValue ? Direction.ASC : Direction.fromString(sortDirParameterValue); return new Sort(order, columnName); }
public static Sort basicSort(SortDto... dtos) { Sort result = null; for(int i=0; i<dtos.length; i++) { SortDto dto = dtos[i]; if(result == null) { result = new Sort(Sort.Direction.fromString(dto.getOrderType()), dto.getOrderField()); } else { result = result.and(new Sort(Sort.Direction.fromString(dto.getOrderType()), dto.getOrderField())); } } return result; } }
private static Direction getDirection(final String sortDirectionStr) { try { return Direction.fromString(sortDirectionStr); } catch (final IllegalArgumentException e) { throw new SortParameterUnsupportedDirectionException(e); } } }
public static final Order mapToOrder(OrderWrapper orderWrapper) { Direction springDirection = Direction.fromString(orderWrapper.getDirection()); Order order = null; if (orderWrapper.isIgnoreCase()) { order = new Order(springDirection, orderWrapper.getProperty()).ignoreCase(); } else { order = new Order(springDirection, orderWrapper.getProperty()); } return order; } }
private static Direction getDirection(final String sortDirectionStr) { try { return Direction.fromString(sortDirectionStr); } catch (final IllegalArgumentException e) { throw new SortParameterUnsupportedDirectionException(e); } } }
@Override public void setAsText(String text) { PropertyValue rawOrder = values.getPropertyValue(orderProperty); Direction order = null == rawOrder ? Direction.ASC : Direction.fromString(rawOrder.getValue().toString()); setValue(new Sort(order, text)); } }
public static Sort getSort(final HttpServletRequest request, final LastSearchParamsDTO lastSearchParamsDTO) { final String columnName = translateSortProperty(SearchFilterUtils.getListName(request), String.valueOf(lastSearchParamsDTO.getSortColum())); final Direction order = Direction.fromString(lastSearchParamsDTO.getSortDirecction()); return new Sort(order, columnName); }
public static Sort basicSort(String orderType, String orderField) { Sort sort = new Sort(Sort.Direction.fromString(orderType), orderField); return sort; }
public static Sort basicSort(SortDto... dtos) { Sort result = null; for(int i=0; i<dtos.length; i++) { SortDto dto = dtos[i]; if(result == null) { result = new Sort(Sort.Direction.fromString(dto.getOrderType()), dto.getOrderField()); } else { result = result.and(new Sort(Sort.Direction.fromString(dto.getOrderType()), dto.getOrderField())); } } return result; } }
public Sort getSort() { if (this.basePage.getOrder() == null || this.basePage.getSortStr() == null) return null; return new Sort(Direction.fromString(this.basePage.getOrder()), this.basePage.getSortStr()); }
public void setSortName(String sort) { if (sort.contains(" ")) { String[] sts = sort.split(" "); this.sort = new Sort(Direction.fromString(sts[1]), sts[0]); } else { this.sort = new Sort(Direction.ASC, sort); } }
@Override public QueryBuilder sort(com.bq.oss.lib.queries.request.Sort sort) { if (sort != null) { query.with(new Sort(Direction.fromString(sort.getDirection().name()), sort.getField())); } return this; }