default ProductQuery byProductType(final Referenceable<ProductType> productType) { return withPredicates(m -> m.productType().is(productType)); }
public static ProductQueryModel of() { return new ProductQueryModel(null, null); }
ProductQueryImpl(){ super(ProductEndpoint.ENDPOINT.endpoint(), ProductQuery.resultTypeReference(), ProductQueryModel.of(), ProductExpansionModel.of(), ProductQueryImpl::new); }
default ProductQuery bySku(final String sku, final ProductProjectionType type) { final QueryPredicate<PartialProductVariantQueryModel> skuPredicate = PartialProductVariantQueryModel.of().sku().is(sku); final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type); final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate); final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate); return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate)); } }
default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) { return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug)); }
public static void deleteProductsProductTypeAndProductDiscounts(final BlockingSphereClient client, final ProductType productType) { client.executeBlocking(ProductDiscountQuery.of().withLimit(500L)).getResults() .forEach(discount -> client.executeBlocking(ProductDiscountDeleteCommand.of(discount))); if (productType != null) { QueryPredicate<Product> ofProductType = ProductQueryModel.of().productType().is(productType); ProductQuery productsOfProductTypeQuery = ProductQuery.of().withPredicates(ofProductType).withLimit(500L); do { final List<Product> products = client.executeBlocking(productsOfProductTypeQuery).getResults(); final List<Product> unpublishedProducts = products.stream().map( product -> { if (product.getMasterData().isPublished()) { return client.executeBlocking(ProductUpdateCommand.of(product, Unpublish.of())); } else { return product; } } ).collect(toList()); final List<CompletionStage<Product>> stages = new LinkedList<>(); unpublishedProducts.forEach( product -> { final CompletionStage<Product> completionStage = client.execute(ProductDeleteCommand.of(product)); stages.add(completionStage); } ); stages.forEach(stage -> SphereClientUtils.blockingWait(stage, 30, TimeUnit.SECONDS)); deleteProductType(client, productType); } while (client.executeBlocking(productsOfProductTypeQuery).getCount() > 0); } }
private void checkIsFoundByPublishedFlag(final Product product, final boolean value) { final Optional<Product> productFromQuery = client().executeBlocking(ProductQuery.of() .withPredicates(m -> { return m.masterData().isPublished().is(value); }) .plusPredicates(m -> m.id().is(product.getId()))).head(); assertThat(productFromQuery.get().getId()).isEqualTo(product.getId()); }
@Test public void queryByTiersWithMinimumQuantity() { withProduct(client(), product -> { final ProductQuery productQuery = ProductQuery.of() .withPredicates(m -> m.masterData().current().variants().prices().tiers().minimumQuantity().isGreaterThan(5)) .plusPredicates(m -> m.is(product)); final List<Product> results = client().executeBlocking(productQuery).getResults(); assertThat(results).hasSize(0); }); }
@Test public void useIdPredicateInsteadOfOffset() throws Exception { final ProductQuery seedQuery = ProductQuery.of() //the original predicate, which queries products for a certain product type //the idea works also for no predicate to get all products .withPredicates(m -> m.productType().is(productType)) //important, we sort by id, otherwise id > $lastId would not make sense .withSort(m -> m.id().sort().asc()) .withLimit(PAGE_SIZE) .withFetchTotal(false);//saves also resources and time final CompletionStage<List<Product>> resultStage = findNext(seedQuery, seedQuery, new LinkedList<>()); final List<Product> actualProducts = resultStage.toCompletableFuture().join(); assertThat(actualProducts).hasSize(createdProducts.size()); //!!! the underlying database has a different algorithm to sort by ID, it is a UUID, which differs from String sorting final List<Product> javaSortedActual = actualProducts.stream().sorted(BY_ID_COMPARATOR).collect(toList()); assertThat(javaSortedActual).isEqualTo(createdProducts); }
public static ProductQueryModel model() { return ProductQueryModel.get(); }
@Test public void transitionState() { withStateByBuilder(client(), builder -> builder.type(PRODUCT_STATE), state -> { withUpdateableProduct(client(), product -> { assertThat(product.getState()).isNull(); final Product updatedProduct = client().executeBlocking(ProductUpdateCommand.of(product, asList(TransitionState.of(state)))); assertThat(updatedProduct.getState()).isEqualTo(state.toReference()); assertEventually(() -> { final PagedQueryResult<ProductStateTransitionMessage> messageQueryResult = client().executeBlocking(MessageQuery.of() .withPredicates(m -> m.resource().is(product)) .forMessageType(ProductStateTransitionMessage.MESSAGE_HINT)); assertThat(messageQueryResult.getResults()).isNotEmpty(); final ProductStateTransitionMessage message = messageQueryResult.head().get(); assertThat(message.getState()).isEqualTo(state.toReference()); }); //check query model final ProductQuery query = ProductQuery.of() .withPredicates(m -> m.id().is(product.getId()).and(m.state().is(state))); final Product productByState = client().executeBlocking(query) .head().get(); assertThat(productByState).isEqualTo(updatedProduct); return updatedProduct; }); }); }
private ProductQuery query(final Product product) { return ProductQuery.of().withPredicates(m -> m.id().is(product.getId())); } }
default ProductQuery bySku(final String sku, final ProductProjectionType type) { final QueryPredicate<EmbeddedProductVariantQueryModel> skuPredicate = EmbeddedProductVariantQueryModel.of().sku().is(sku); final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type); final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate); final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate); return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate)); } }
default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) { return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug)); }
@Test public void queryProductsWithAnyDiscount() throws Exception { withUpdateableProductDiscount(client(), (ProductDiscount productDiscount, Product product) -> { final ProductQuery query = ProductQuery.of() .withPredicates(m -> m.id().is(product.getId()) .and(m.masterData().staged().masterVariant().prices().discounted().isPresent())); final Duration maxWaitTime = Duration.ofMinutes(2); final Duration waitBeforeRetry = Duration.ofMillis(500); assertEventually(maxWaitTime, waitBeforeRetry, () -> { final Optional<Product> loadedProduct = client().executeBlocking(query).head(); assertThat(loadedProduct.isPresent()).isTrue(); assertThat(loadedProduct.get().getId()).isEqualTo(product.getId()); }); return productDiscount; }); }
@Test public void queryByTiersWithValue() { withProduct(client(), product -> { final ProductQuery productQuery = ProductQuery.of() .withPredicates(m -> m.masterData().current().variants().prices().tiers().value().currencyCode().is("EUR")) .plusPredicates(m -> m.is(product)); final List<Product> results = client().executeBlocking(productQuery).getResults(); assertThat(results).hasSize(0); }); }
public static ProductQueryModel model() { return ProductQueryModel.get(); }
private CompletionStage<List<Product>> findNext(final ProductQuery seedQuery, final ProductQuery query, final List<Product> products) { final CompletionStage<PagedQueryResult<Product>> pageResult = sphereClient().execute(query); return pageResult.thenCompose(page -> { final List<Product> results = page.getResults(); products.addAll(results); final boolean isLastQueryPage = results.size() < PAGE_SIZE; if (isLastQueryPage) { return CompletableFuture.completedFuture(products); } else { final String lastId = getIdForNextQuery(page); return findNext(seedQuery, seedQuery .plusPredicates(m -> m.id().isGreaterThan(lastId)), products); } }); }
default ProductQuery bySku(final String sku, final ProductProjectionType type) { final QueryPredicate<EmbeddedProductVariantQueryModel> skuPredicate = EmbeddedProductVariantQueryModel.of().sku().is(sku); final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type); final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate); final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate); return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate)); } }
default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) { return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug)); }