private Query<T, F> mixInSortOrders(Query<T, F> query) { if (sortOrders.isEmpty()) { return query; } Set<String> sortedPropertyNames = query.getSortOrders().stream() .map(SortOrder::getSorted).collect(Collectors.toSet()); List<QuerySortOrder> combinedSortOrders = Stream .concat(query.getSortOrders().stream(), sortOrders.stream() .filter(order -> !sortedPropertyNames .contains(order.getSorted()))) .collect(Collectors.toList()); return new Query<>(query.getOffset(), query.getLimit(), combinedSortOrders, query.getInMemorySorting(), query.getFilter().orElse(null)); }
@Override protected QuerySortOrder createSortOrder(String by, SortDirection direction) { return new QuerySortOrder(by, direction); } }
private static QuerySort fromOrder(PropertySet<?> set, QuerySortOrder order) { Path<?> path = getPathByName(set, order.getSorted()).orElseThrow(() -> new IllegalArgumentException( "No property of the set matches with sort name: " + order.getSorted())); SortDirection direction = (order.getDirection() != null && order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING) ? SortDirection.DESCENDING : SortDirection.ASCENDING; return QuerySort.of(path, direction); }
/** * Get a {@link QuerySort} form given {@link QuerySortOrder}, if a {@link Path} property which corresponds to the * ordered property id is available. * <p> * If a {@link PropertySortGenerator} is bound to the property to sort, it will be used to provide the query sort. * </p> * @param order Sort order * @return Optional sort */ protected Optional<QuerySort> sortFromOrder(QuerySortOrder order) { QuerySort sort = null; Optional<PROPERTY> p = getPropertyById(order.getSorted()); if (p.isPresent()) { final PROPERTY property = p.get(); sort = getPropertySortGenerator(property).map(g -> g.getQuerySort(property, order.getDirection() == com.vaadin.shared.data.sort.SortDirection.ASCENDING)).orElse(null); if (sort == null && Path.class.isAssignableFrom(property.getClass())) { sort = QuerySort.of((Path<?>) property, (order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING) ? SortDirection.DESCENDING : SortDirection.ASCENDING); } } return Optional.ofNullable(sort); }
QuerySort sort = null; final SortDirection direction = (order.getDirection() != null && order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING) ? SortDirection.DESCENDING : SortDirection.ASCENDING; Optional<?> p = getConfiguration().flatMap(c -> c.getPropertyById(order.getSorted())); if (p.isPresent()) { final Object property = p.get(); sort = QuerySort.of(Path.of(order.getSorted(), Object.class), direction);
private HierarchicalQuery<T, F> mixInSortOrders( HierarchicalQuery<T, F> query) { if (sortOrders.isEmpty()) { return query; } Set<String> sortedPropertyNames = query.getSortOrders().stream() .map(SortOrder::getSorted).collect(Collectors.toSet()); List<QuerySortOrder> combinedSortOrders = Stream .concat(query.getSortOrders().stream(), sortOrders.stream() .filter(order -> !sortedPropertyNames .contains(order.getSorted()))) .collect(Collectors.toList()); return new HierarchicalQuery<>(query.getOffset(), query.getLimit(), combinedSortOrders, query.getInMemorySorting(), query.getFilter().orElse(null), query.getParent()); }
/** * Appends sorting with given sort direction. * * @param by * the object to sort by * @param direction * the sort direction * * @return this sort builder */ protected SortBuilder append(String by, SortDirection direction) { sortOrder.add(new QuerySortOrder(by, direction)); return this; }
@Override protected Stream fetchChildrenFromBackEnd(HierarchicalQuery query) { int offset = query.getOffset(); int limit = query.getLimit(); Account parent = (Account) query.getParent(); Iterator it = query.getSortOrders().iterator(); while (it.hasNext()) { QuerySortOrder order = (QuerySortOrder) it.next(); orders.put(order.getSorted(),order.getDirection() == SortDirection.DESCENDING); } try { return getAllChildren(offset,limit,orders,parent); } catch (Exception e) { getApp().getLog().error(e); return null; } } @Override
/** * Sets strings describing back end properties to be used when sorting * this column. * <p> * By default, the {@link #setId(String) column id} will be used as the * sort property. * * @param properties * the array of strings describing backend properties * @return this column */ public Column<T, V> setSortProperty(String... properties) { Objects.requireNonNull(properties, "Sort properties can't be null"); return setSortOrderProvider(dir -> Arrays.stream(properties) .map(s -> new QuerySortOrder(s, dir))); }
final int startPage = (int) Math.floor((double) offset / pageSize); final int endPage = (int) Math.floor((double) (offset + pageSize - 1) / pageSize); final Sort.Direction sortDirection = sortOrder.isEmpty() || sortOrder.get(0).getDirection() == SortDirection.ASCENDING ? Sort.Direction.ASC : Sort.Direction.DESC; final String sortProperty = sortOrder.isEmpty() ? "id" : sortOrder.get(0).getSorted(); if (startPage != endPage) { List<Person> page0 = repo.findByNameLikeIgnoreCase(likeFilter, PageRequest.of(startPage, pageSize, sortDirection, sortProperty));
@Test public void getItems() throws Exception { // GIVEN WHEN dataProvider.filterByCategory(PulseItemCategory.ALL_TASKS); Query query = new Query<Task, Void>(0, 9, Collections.emptyList(), null, null); List<Task> items = (List<Task>) dataProvider.fetchFromBackEnd(query).collect(Collectors.toList()); dataProvider.filterByCategory(PulseItemCategory.UNCLAIMED); query = new Query<Task, Void>(0, 3, ImmutableList.of(new QuerySortOrder(TaskConstants.ID, SortDirection.DESCENDING)), null, null); List<Task> itemsSorted = (List<Task>) dataProvider.fetchFromBackEnd(query).collect(Collectors.toList()); // THEN assertThat(items.size(), is(9)); assertThat(items, containsIdsInOrder(1, 2, 3, 4, 5, 6, 7, 8, 9)); assertThat(itemsSorted.size(), is(3)); assertThat(itemsSorted, containsIdsInOrder(3, 2, 1)); } }
public DataProvider getParentDataProvider() { Map<String,Boolean> orders = new HashMap<>(); DataProvider dataProvider = DataProvider.fromCallbacks( (CallbackDataProvider.FetchCallback) query -> { int offset = query.getOffset(); int limit = query.getLimit(); Iterator it = query.getSortOrders().iterator(); while (it.hasNext()) { QuerySortOrder order = (QuerySortOrder) it.next(); orders.put(order.getSorted(),order.getDirection() == SortDirection.DESCENDING); } try { return getPossibleParents(offset,limit,orders); } catch (Exception e) { getApp().getLog().error(e); return null; } }, (CallbackDataProvider.CountCallback<Account, Void>) query -> { try { return getPossibleParentsCount(); } catch (Exception e) { getApp().getLog().error(e); return 0; } }); return dataProvider; }
@Test public void getItemsWithGrouping() throws Exception { // GIVEN dataProvider.filterByCategory(PulseItemCategory.INFO); dataProvider.setGrouping(true); Query query = new Query<Message, Void>(0, 3, ImmutableList.of(new QuerySortOrder(MessageConstants.ID, SortDirection.ASCENDING)), null, null); // WHEN List<Message> items = (List<Message>) dataProvider.fetchFromBackEnd(query).collect(Collectors.toList()); // THEN no additional data for grouping assertThat(items.size(), is(3)); assertThat(items, containsIdsInOrder(7, 8, 9)); } }
@Override public DataProvider getDataProvider() { Map<String,Boolean> orders = new HashMap<>(); DataProvider dataProvider = DataProvider.fromCallbacks( (CallbackDataProvider.FetchCallback) query -> { int offset = query.getOffset(); int limit = query.getLimit(); for (Object o : query.getSortOrders()) { QuerySortOrder order = (QuerySortOrder) o; orders.put(order.getSorted(), order.getDirection() == SortDirection.DESCENDING); } User user = (User) query.getFilter().orElse(null); try { return getAll(offset,limit,orders,user); } catch (Exception e) { getApp().getLog().error(e); return null; } }, (CallbackDataProvider.CountCallback) query -> { User user = (User) query.getFilter().orElse(null); try { return getItemCount(user); } catch (Exception e) { getApp().getLog().error(e); return 0; } }); return (ConfigurableFilterDataProvider<Consumer,Void,User>) dataProvider.withConfigurableFilter(); }
@Test public void getItems() throws Exception { // GIVEN WHEN dataProvider.filterByCategory(PulseItemCategory.ALL_MESSAGES); Query query = new Query<Message, Void>(0, 9, Collections.emptyList(), null, null); List<Message> items = (List<Message>) dataProvider.fetchFromBackEnd(query).collect(Collectors.toList()); dataProvider.filterByCategory(PulseItemCategory.PROBLEM); query = new Query<Message, Void>(0, 6, ImmutableList.of(new QuerySortOrder(MessageConstants.ID, SortDirection.DESCENDING)), null, null); List<Message> itemsSorted = (List<Message>) dataProvider.fetchFromBackEnd(query).collect(Collectors.toList()); // THEN assertThat(items.size(), is(9)); assertThat(items, containsIdsInOrder(1, 2, 3, 4, 5, 6, 7, 8, 9)); assertThat(itemsSorted.size(), is(6)); assertThat(itemsSorted, containsIdsInOrder(6, 5, 4, 3, 2, 1)); }
@Override public DataProvider getDataProvider() { Map<String,Boolean> orders = new HashMap<>(); DataProvider dataProvider = DataProvider.fromCallbacks( (CallbackDataProvider.FetchCallback) query -> { int offset = query.getOffset(); int limit = query.getLimit(); for (Object o : query.getSortOrders()) { QuerySortOrder order = (QuerySortOrder) o; orders.put(order.getSorted(), order.getDirection() == SortDirection.DESCENDING); } DateRange dateRange = (DateRange) query.getFilter().orElse(null); try { return getAll(offset,limit,orders,defaultJournalId,dateRange); } catch (Exception e) { getApp().getLog().error(e); return null; } }, (CallbackDataProvider.CountCallback) query -> { DateRange dateRange = (DateRange) query.getFilter().orElse(null); try { return getItemCount(defaultJournalId,dateRange); } catch (Exception e) { getApp().getLog().error(e); return 0; } }); return (ConfigurableFilterDataProvider<GLTransaction,Void,DateRange>) dataProvider.withConfigurableFilter(); }