com.vaadin.flow.data.provider.Query Java Examples

private void addAllowCustomValuesDemo() {
    MultiselectComboBox<String> multiselectComboBox = new MultiselectComboBox();
    multiselectComboBox.setLabel("Allow custom values");
    multiselectComboBox.setPlaceholder("Select existing or input custom value");
    multiselectComboBox.setWidth("100%");
    List<String> items = Arrays.asList("Java", "Go", "Python", "C#");
    multiselectComboBox.setItems(items);

    multiselectComboBox.addCustomValuesSetListener(e -> {
        Set<String> existingSelected = multiselectComboBox.getValue().stream().collect(Collectors.toSet());
        existingSelected.add(e.getDetail());
        List<String> updatedItems = multiselectComboBox.getDataProvider().fetch(new Query<>()).collect(Collectors.toList());
        updatedItems.add(e.getDetail());
        multiselectComboBox.setItems(updatedItems);
        multiselectComboBox.setValue(existingSelected);
    });

    Button getValueBtn = new Button("Get value");
    getValueBtn.addClickListener(
        event -> multiselectComboBoxValueChangeHandler(
            multiselectComboBox));

    add(buildDemoContainer(multiselectComboBox, getValueBtn));
}
 

@Test
public void testGetIdOfReplacementItem() {
    Assert.assertFalse("Test object was stale before making any changes.",
            dataProvider.isStale(TEST_OBJECT));

    dataProvider.refreshItem(new StrBean("Replacement TestObject", 10, -2));

    StrBean fromDataProvider = dataProvider.fetch(new Query<>()).findFirst()
            .get();
    Object id = dataProvider.getId(fromDataProvider);

    Assert.assertNotEquals("DataProvider did not return the replacement",
            TEST_OBJECT, fromDataProvider);

    Assert.assertEquals("DataProvider not using correct identifier getter",
            TEST_OBJECT.getId(), id);

    Assert.assertTrue("Old test object should be stale",
            dataProvider.isStale(TEST_OBJECT));
}
 

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 Sort.unsorted();
    } else {
        return Sort.by(orders);
    }
}
 

@Test
public void predicate_combinedFilters() {
    configurablePredicate.setFilter(Integer.valueOf(50));

    Assert.assertEquals("Both filters should be used", 0,
            configurablePredicate.size(new Query<>("Xyz")));

    configurablePredicate.setFilter(null);

    Assert.assertEquals("Only zyz filter should be used", 1,
            configurablePredicate.size(new Query<>("Xyz")));
}
 

@Test
public void predicate_queryFilter() {
    Assert.assertEquals("Query filter should be used", 1,
            configurablePredicate.size(new Query<>("Xyz")));

    Assert.assertEquals("null query filter should return all items", 100,
            configurablePredicate.size(new Query<>()));
}
 

@Test
public void predicate_setFilter() {
    configurablePredicate.setFilter(Integer.valueOf(50));

    Assert.assertEquals("Set filter should be used", 49,
            configurablePredicate.size(new Query<>()));

    configurablePredicate.setFilter(null);

    Assert.assertEquals("null filter should return all items", 100,
            configurablePredicate.size(new Query<>()));
}
 

@Test
public void void_setFilter() {
    configurableVoid.setFilter(xyzFilter);

    Assert.assertEquals("Set filter should be used", 1,
            configurableVoid.size(new Query<>()));

    configurableVoid.setFilter(null);

    Assert.assertEquals("null filter should return all items", 100,
            configurableVoid.size(new Query<>()));
}
 

@Test
public void testGetIdOfItem() {
    Object id = dataProvider.fetch(new Query<>()).findFirst()
            .map(dataProvider::getId).get();
    Assert.assertEquals("DataProvider not using correct identifier getter",
            TEST_OBJECT.getId(), id);
}
 

@Override
@SuppressWarnings("serial")
default <C> HierarchicalDataProvider<T, C> withConvertedFilter(
        SerializableFunction<C, F> filterConverter) {
    return new HierarchicalFilterDataProviderWrapper<T, C, F>(this) {
        @Override
        protected F getFilter(Query<T, C> query) {
            return FilterUtils.convertFilter(filterConverter, query);
        }
    };
}
 

private SearchOverlayButton<TestSearchResult, SerializablePredicate<TestSearchResult>> initSearchOverlayButton() {
    // The data provider that provides the entities for the search
    ListDataProvider<TestSearchResult> listDataProvider = new ListDataProvider<>(Arrays.asList(
            new TestSearchResult("Header1", "Description1"),
            new TestSearchResult("Header2", "Description2"),
            new TestSearchResult("Header3", "Description3"),
            new TestSearchResult("Header4", "Description4"),
            new TestSearchResult("Header5", "Description5"),
            new TestSearchResult("Header6", "Description6"),
            new TestSearchResult("Header7", "Description7"),
            new TestSearchResult("Header8", "Description8"),
            new TestSearchResult("Header9", "Description9"),
            new TestSearchResult("Header10", "Description10")
    ));

    return new SearchOverlayButtonBuilder<TestSearchResult, SerializablePredicate<TestSearchResult>>()
            // add the data provider
            .withDataProvider(listDataProvider)
            // Set the query that is executed to filter the Entities above
            .withQueryProvider(s -> new Query<>(testEntity -> !s.equals("") && testEntity.getHeader().startsWith(s)))
            // Set the producer that produces Components to be shown as search result
            .withDataViewProvider(queryResult -> {
                RippleClickableCard card = new RippleClickableCard(new Item(queryResult.getHeader(), queryResult.getDescription()));
                card.setWidthFull();
                card.setBackground("var(--lumo-base-color)");
                return card;
            })
            // A Listener to react if a search result was clicked
            .withQueryResultListener(testSearchResult -> Notification.show(testSearchResult.getHeader()))
            .build();
}
 

@Override
public void furtherConfiguration(AppLayoutBuilder builder) {
    ListDataProvider<TestSearchResult> dataProvider = new ListDataProvider<>(Arrays.asList(
            new TestSearchResult("Header1", "Description1"),
            new TestSearchResult("Header2", "Description2"),
            new TestSearchResult("Header3", "Description3"),
            new TestSearchResult("Header4", "Description4"),
            new TestSearchResult("Header5", "Description5"),
            new TestSearchResult("Header6", "Description6"),
            new TestSearchResult("Header7", "Description7"),
            new TestSearchResult("Header8", "Description8"),
            new TestSearchResult("Header9", "Description9"),
            new TestSearchResult("Header10", "Description10")
    ));

    SearchOverlayButton<TestSearchResult, SerializablePredicate<TestSearchResult>> button = new SearchOverlayButtonBuilder<TestSearchResult, SerializablePredicate<TestSearchResult>>()
            .withDataProvider(dataProvider)
            .withQueryProvider(s -> new Query<TestSearchResult, SerializablePredicate<TestSearchResult>>(testEntity -> !s.equals("") && testEntity.getHeader().startsWith(s)))
            .withDataViewProvider(result -> {
                RippleClickableCard card = new RippleClickableCard(new Item(result.getHeader(), result.getDescription()));
                card.setWidthFull();
                card.setBackground("var(--lumo-base-color)");
                return card;
            })
            .withQueryResultListener(testSearchResult -> Notification.show(testSearchResult.header + " clicked"))
            .build();

    button.setId("it-test-search-button");
    button.getSearchView().getSearchField().setId("it-test-search-field");
    button.getSearchView().getCloseButton().setId("it-test-search-close");
    builder.withAppBar(button);
}
 

private <T> Stream<T> fromPageable(Page<T> result, Pageable pageable,
        Query<T, ?> query) {
    List<T> items = result.getContent();

    int firstRequested = query.getOffset();
    int nrRequested = query.getLimit();
    int firstReturned = (int) pageable.getOffset();
    int firstReal = firstRequested - firstReturned;
    int afterLastReal = firstReal + nrRequested;
    if (afterLastReal > items.size()) {
        afterLastReal = items.size();
    }
    return items.subList(firstReal, afterLastReal).stream();
}
 

public SearchOverlayButtonBuilder<T, F> withQueryProvider(Function<String, Query<T, F>> queryFunction) {
    this.queryFunction = queryFunction;
    return this;
}
 

private void refreshAllData(boolean forceServerSideFiltering) {
    setClientSideFilter(!forceServerSideFiltering && getDataProvider()
            .size(new Query<>()) <= getPageSizeDouble());

    reset();
}
 

@Override
public void setDataProvider(ListDataProvider<T> listDataProvider) {
    super.setDataProvider(listDataProvider);
    items = listDataProvider.fetch(new Query<>())
            .collect(Collectors.toList());
}
 

@Override
public int size(Query<T, F> query) {
    return super.size(getFilterQuery(query));
}
 

@Test(expected = Exception.class)
@SuppressWarnings({ "unchecked", "rawtypes" })
public void void_nonNullQueryFilter_throws() {
    configurableVoid
            .size((Query) new Query<StrBean, String>("invalid filter"));
}
 

@Override
public Stream<T> fetch(Query<T, F> query) {
    return super.fetch(getFilterQuery(query));
}
 

@Override
public int size(Query<Object, Object> t) {
    return 0;
}
 

@Override
public Stream<Object> fetch(Query<Object, Object> t) {
    return null;
}
 

private Query<T, F> getFilterQuery(Query<T, F> t) {
    return new Query(t.getOffset(), t.getLimit(), t.getSortOrders(),
            t.getInMemorySorting(), filter);
}
 

@Override
protected Stream<T> fetchFromBackEnd(Query<T, F> query) {
    Pageable pageable = getPageable(query);
    Page<T> result = fetchFromBackEnd(query, pageable);
    return fromPageable(result, pageable, query);
}
 

@Override
public Stream<StrBean> fetch(Query<StrBean, Void> query) {
    return backend.stream().skip(query.getOffset()).limit(query.getLimit());
}
 

@Override
public int size(Query<StrBean, Void> t) {
    return backend.size();
}
 

protected abstract Page<T> fetchFromBackEnd(Query<T, F> query,
Pageable pageable);
 

@Override
public Stream<T> fetch(Query<T, F> query) {
    return HierarchicalDataProvider.super.fetch(query);
}
 

@Override
public int size(Query<T, F> query) {
    return HierarchicalDataProvider.super.size(query);
}
 

@Override
public Stream<T> fetch(Query<T, Q> query) {
    return HierarchicalConfigurableFilterDataProvider.super.fetch(
            query);
}
 

@Override
public int size(Query<T, Q> t) {
    return HierarchicalConfigurableFilterDataProvider.super.size(t);
}
 

protected void findAllButtonClicked() {
    grid.asSingleSelect().clear();
    refreshGrid();
    showNotification(String.format(rowCountCaption, grid.getDataProvider().size(new Query())));
}