public ProductVariantFilterSearchModel allVariants() { return new ProductVariantFilterSearchModel(this, "variants"); }
public MoneyFilterSearchModel<ProductProjection> price() { return moneyFilterSearchModel("price"); } }
default ProductProjectionSearch bySku(final List<String> skus) { return withQueryFilters(m -> m.allVariants().sku().isIn(skus)); }
@Test public void filterByEvilCharacterWord() throws Exception { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .plusQueryFilters(productModel -> productModel.allVariants().attribute().ofString(ATTR_NAME_EVIL).is(EVIL_CHARACTER_WORD)); assertEventually(Duration.ofSeconds(60), Duration.ofMillis(200), () -> { final PagedSearchResult<ProductProjection> result = executeEvilSearch(search); assertThat(result.getTotal()).as("total").isEqualTo(1); }); }
@Test public void channelsFilterDsl() { final StringHttpRequestBody body = (StringHttpRequestBody) ProductProjectionSearch.ofStaged().plusQueryFilters(m -> m.allVariants().availability().channels().channelId("channel-id-12") .availableQuantity().isGreaterThanOrEqualTo(new BigDecimal(3))).httpRequestIntent().getBody(); assertThat(body.getString()).contains("filter.query=variants.availability.channels.channel-id-12.availableQuantity%3Arange%283+to+*%29"); }
@Test public void canAccessPriceAmount() throws Exception { assertThat(FACET_MODEL.allVariants().price().centAmount().allTerms().expression()).isEqualTo("variants.price.centAmount"); assertThat(FILTER_MODEL.allVariants().price().centAmount().is(1000L)).extracting(expression()).containsExactly("variants.price.centAmount:1000"); assertThat(SORT_MODEL.allVariants().price().descWithMinValue().expression()).isEqualTo("price desc.min"); }
/** * Creates filters for the scopedPriceDiscounted property of a product variant. * * {@include.example io.sphere.sdk.products.search.ScopedPriceSearchIntegrationTest#discounts()} * * @return filters model */ public TermFilterExistsAndMissingSearchModel<ProductProjection, Boolean> scopedPriceDiscounted() { return booleanSearchModel("scopedPriceDiscounted").filtered(); }
public ExistsAndMissingFilterSearchModelSupport<ProductProjection> prices() { return existsAndMissingFilterSearchModelSupport("prices"); }
@Test public void filterByProductVariantKey() { final List<String> keys = Stream.of(product1, product2) .map(product -> product.getMasterData().getStaged().getMasterVariant().getKey()) .collect(toList()); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.allVariants().key().isIn(keys)); assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> { final List<ProductProjection> results = client().executeBlocking(search).getResults(); assertThat(results) .extracting(m -> m.getMasterVariant().getKey()) .containsOnly(keys.get(0), keys.get(1)); }); }
@Test public void prices() { checkFilter(builder -> { final ProductVariantDraft oldMaster = builder.getMasterVariant(); final ProductVariantDraft masterWithPrices = ProductVariantDraftBuilder.of(oldMaster) .prices(singletonList(PriceDraft.of(EURO_1))) .build(); return builder.masterVariant(masterWithPrices); }, m -> m.allVariants().prices()); }
@Test public void filtersByAnyTerm() throws Exception { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .plusQueryFilters(productModel -> productModel.allVariants().attribute().ofNumber(ATTR_NAME_SIZE).isIn(asList(valueOf(36), valueOf(38)))); testResultIds(search, resultIds -> assertThat(resultIds).containsOnly(product1.getId(), product2.getId())); }
@Test public void searchForAvailableQuantityRanges() { withProductOfStock(client(), 10, productWith10Items -> { withProductOfStock(client(), 5, productWith5Items -> { final RangeFacetExpression<ProductProjection> productProjectionRangeFacetExpression = ProductProjectionSearchModel.of() .facet().allVariants().availability().availableQuantity().onlyGreaterThanOrEqualTo(new BigDecimal(1)); final ProductProjectionSearch request = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.id().isIn(asList(productWith10Items.getId(), productWith5Items.getId()))) .plusQueryFilters(m -> m.allVariants().availability().availableQuantity().isGreaterThanOrEqualTo(new BigDecimal(6))) .plusFacets(productProjectionRangeFacetExpression); assertEventually(() -> { final PagedSearchResult<ProductProjection> res = client().executeBlocking(request); assertThat(res.getResults()).hasSize(1); assertThat(res.getResults().get(0).getId()) .as("finds only the product with the sufficient amount stocked") .isEqualTo(productWith10Items.getId()); final RangeFacetResult facetResult = res.getFacetResult(productProjectionRangeFacetExpression); assertThat(facetResult.getRanges().get(0).getMax()) .isEqualTo("10.0"); }); }); }); }
@Test public void canAccessPriceCurrency() throws Exception { assertThat(FACET_MODEL.allVariants().price().currency().allTerms().expression()).isEqualTo("variants.price.currencyCode"); assertThat(FILTER_MODEL.allVariants().price().currency().is(currency("EUR"))).extracting(expression()).containsExactly("variants.price.currencyCode:\"EUR\""); }
/** * Creates filters for the scopedPriceDiscounted property of a product variant. * * {@include.example io.sphere.sdk.products.search.ScopedPriceSearchIntegrationTest#discounts()} * * @return filters model */ public TermFilterExistsAndMissingSearchModel<ProductProjection, Boolean> scopedPriceDiscounted() { return booleanSearchModel("scopedPriceDiscounted").filtered(); }
public ExistsAndMissingFilterSearchModelSupport<ProductProjection> prices() { return existsAndMissingFilterSearchModelSupport("prices"); }
private void testBlueFilter(final Function<List<FilterExpression<ProductProjection>>, ProductProjectionSearch> createSearch) { final ProductProjectionSearch search = createSearch.apply(PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).is("blue")); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); final Predicate<ProductVariant> isBlue = variant -> variant.findAttribute(COLOR_ATTRIBUTE_ACCESS) .map(color -> color.equals("blue")) .orElse(false); final Condition<ProductVariant> blueVariant = new Condition<>(isBlue, "variant is blue"); assertThat(results) .flatExtracting(ProductProjection::getAllVariants) .areAtLeastOne(notMatching(blueVariant)) .areAtLeastOne(blueVariant); final List<ProductVariant> allMatchingVariants = results.stream() .flatMap(r -> r.findMatchingVariants().stream()) .collect(toList()); assertThat(allMatchingVariants).are(blueVariant); assertThat(results) .extracting(r -> r.findFirstMatchingVariant().get()) .containsOnlyElementsOf(allMatchingVariants); }); }
default ProductProjectionSearch bySku(final String sku) { return withQueryFilters(m -> m.allVariants().sku().is(sku)); }
public MoneyFilterSearchModel<ProductProjection> price() { return moneyFilterSearchModel("price"); }
public ProductVariantFilterSearchModel allVariants() { return new ProductVariantFilterSearchModel(this, "variants"); }
@Test public void searchForIsNotOnStock() { withProductOfStock(client(), 0, product -> { final ProductProjectionSearch request = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.id().is(product.getId())) .plusQueryFilters(m -> m.allVariants().availability().isOnStock().is(false)); assertEventually(() -> { final PagedSearchResult<ProductProjection> res = client().executeBlocking(request); assertThat(res.getResults()).hasSize(0); }); }); }