protected SphereRequest<PagedQueryResult<Product>> queryRequestForQueryAll() { return ProductQuery.of(); }
public static ProductQueryBuilder of() { return new ProductQueryBuilder(ProductQuery.of()); }
public static ProductQueryBuilder of() { return new ProductQueryBuilder(ProductQuery.of()); }
public static ProductQueryBuilder of() { return new ProductQueryBuilder(ProductQuery.of()); }
private ProductQuery query(final Product product) { return ProductQuery.of().withPredicates(m -> m.id().is(product.getId())); } }
public static void withUpdateableProduct(final BlockingSphereClient client, final Supplier<? extends ProductDraft> creator, final Function<Product, Product> user) { final ProductDraft productDraft = creator.get(); final String slug = englishSlugOf(productDraft); final PagedQueryResult<Product> pagedQueryResult = client.executeBlocking(ProductQuery.of().bySlug(ProductProjectionType.CURRENT, Locale.ENGLISH, slug)); delete(client, pagedQueryResult.getResults()); final Product product = client.executeBlocking(ProductCreateCommand.of(productDraft)); final Product possiblyUpdateProduct = user.apply(product); delete(client, possiblyUpdateProduct); }
@BeforeClass public static void setupProducts() { productType = client().executeBlocking(ProductTypeQuery.of().byName(PRODUCT_TYPE_NAME)).head() .orElseGet(() -> createProductType()); evilProductType = client().executeBlocking(ProductTypeQuery.of().byName(EVIL_PRODUCT_TYPE_NAME)).head() .orElseGet(() -> createEvilProductType()); final Query<Product> query = ProductQuery.of() .withPredicates(product -> product.masterData().staged().masterVariant().sku().isIn(asList(SKU1, SKU2, SKU3, SKU_A, SKU_B))); final List<Product> products = client().executeBlocking(query).getResults(); final Function<String, Optional<Product>> findBySku = sku -> products.stream().filter(p -> sku.equals(p.getMasterData().getStaged().getMasterVariant().getSku())).findFirst(); product1 = findBySku.apply(SKU1).orElseGet(() -> createTestProduct(productType, "Schuh", "shoe", "blue", 38, 46, SKU1, SLUG1)); product2 = findBySku.apply(SKU2).orElseGet(() -> createTestProduct(productType, "Hemd", "shirt", "red", 36, 44, SKU2, SLUG2)); product3 = findBySku.apply(SKU3).orElseGet(() -> createTestProduct(productType, "Kleider", "dress", "blue", 40, 42, SKU3, SLUG3)); evilProduct1 = findBySku.apply(SKU_A).orElseGet(() -> createEvilTestProduct(evilProductType, EVIL_CHARACTER_WORD, EVIL_PRODUCT_TYPE_NAME + "foo", SKU_A)); evilProduct2 = findBySku.apply(SKU_B).orElseGet(() -> createEvilTestProduct(evilProductType, EVIL_PRODUCT_TYPE_NAME + "bar", EVIL_CHARACTER_WORD, SKU_B)); }
public static Data createScenario(final BlockingSphereClient client) { final ProductType productType = client.executeBlocking(ProductTypeQuery.of().byName(PRODUCT_TYPE_NAME)).head() .orElseGet(() -> createProductType(client)); final Query<Product> query = ProductQuery.of() .withPredicates(m -> m.masterData().staged().masterVariant().sku().isIn(asList(SKU1, SKU2, SKU_SOME_ID, SKU_OTHER_ID))); final List<Product> products = client.executeBlocking(query).getResults(); final Function<String, Optional<Product>> findBySku = sku -> products.stream().filter(p -> sku.equals(p.getMasterData().getStaged().getMasterVariant().getSku())).findFirst(); final Product productA = findBySku.apply(SKU_SOME_ID).orElseGet(() -> createTestProduct(client, "Some Id", ProductVariantDraftBuilder.of().sku(SKU_SOME_ID).build(), productType)); final Product productB = findBySku.apply(SKU_OTHER_ID).orElseGet(() -> createTestProduct(client, "Other Id", ProductVariantDraftBuilder.of().sku(SKU_OTHER_ID).build(), productType)); final Product product1 = findBySku.apply(SKU1).orElseGet(() -> createProduct1(client, productA, productB, productType)); final Product product2 = findBySku.apply(SKU2).orElseGet(() -> createProduct2(client, productA, productB, productType)); final Data data = new Data(productType, product1, product2, productA, productB); return data; }
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()); }
protected SphereRequest<PagedQueryResult<Product>> queryObjectForName(final String name) { return ProductQuery.of().withPredicates(m -> m.masterData().current().name().lang(ENGLISH).is(name)); }
protected SphereRequest<PagedQueryResult<Product>> queryObjectForNames(final List<String> names) { return ProductQuery.of().withPredicates(m -> m.masterData().current().name().lang(ENGLISH).isIn(names)); }
@Test public void expandVariants() { CustomerGroupFixtures.withB2cCustomerGroup(client(), customerGroup -> ProductFixtures.withProductType(client(), randomString(), productType -> withProduct(client(), new VariantsCottonTShirtProductDraftSupplier(productType, randomString(), customerGroup), product -> { final PagedQueryResult<Product> result = client().executeBlocking(ProductQuery.of() .withPredicates(m -> m.id().is(product.getId())) .withExpansionPaths(m -> m.masterData().staged().variants().prices().customerGroup()) .withLimit(1L)); final Price priceWithCustomerGroup = result.head().get().getMasterData().getStaged().getVariants().get(0).getPrices().stream() .filter(price -> Objects.equals(price.getCustomerGroup(), customerGroup.toReference())) .findFirst().get(); assertThat(priceWithCustomerGroup.getCustomerGroup().getObj()).isNotNull().isEqualTo(customerGroup); }) ) ); }
@Override public Query<Product> get() { final QueryPredicate<Product> predicate = ProductQueryModel.of(). masterData().current().name().lang(Locale.ENGLISH).is("simple cotton t-shirt"); return ProductQuery.of().withPredicates(predicate); } }
@Test public void selectAPriceByCurrencyInProductQuery() { final List<PriceDraft> prices = asList(PriceDraft.of(EURO_30), PriceDraft.of(USD_20)); withProductOfPrices(prices, product -> { final ProductQuery request = ProductQuery.of() .withPredicates(m -> m.id().is(product.getId()))//to limit the test scope .withPriceSelection(PriceSelection.of(EUR));//price selection config final PagedQueryResult<Product> result = client().executeBlocking(request); assertThat(result.getCount()).isEqualTo(1); final ProductVariant masterVariant = result.getResults().get(0).getMasterData().getStaged().getMasterVariant(); assertThat(masterVariant.getPrice()).isNotNull().has(price(PriceDraft.of(EURO_30))); }); }
@Test public void queryBySku() { final String sku = "sku2000"; final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .sku(sku) .attributes(Sizes.ATTRIBUTE.draftOf(Sizes.S), Colors.ATTRIBUTE.draftOf(Colors.GREEN)) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, en("foo"), en("foo-slug"), masterVariant).build(); client().executeBlocking(ProductCreateCommand.of(productDraft)); final PagedQueryResult<Product> result = client().executeBlocking(ProductQuery.of().bySku(sku, STAGED)); assertThat(result.getResults()).hasSize(1); assertThat(result.getResults().get(0).getMasterData().getStaged().getMasterVariant().getSku()).contains(sku); assertThat(result.getResults().get(0).getMasterData().getStaged().getMasterVariant().findAttribute(Colors.ATTRIBUTE)).contains(Colors.GREEN); assertThat(result.getResults().get(0).getMasterData().getStaged().getMasterVariant().findAttribute(Sizes.ATTRIBUTE)).contains(Sizes.S); }
@AfterClass @BeforeClass public static void deleteProductsAndProductType() { final List<ProductType> productTypes = client().executeBlocking(ProductTypeQuery.of().byName(PRODUCT_TYPE_NAME)).getResults(); if (!productTypes.isEmpty()) { final ProductQuery productQuery = ProductQuery.of() .withPredicates(m -> m.productType().isIn(productTypes)) .withLimit(500L); client().executeBlocking(productQuery).getResults().forEach(p -> client().executeBlocking(ProductDeleteCommand.of(p))); productTypes.forEach(p -> client().executeBlocking(ProductTypeDeleteCommand.of(p))); } }
public static Product referenceableProduct(final BlockingSphereClient client) { final ProductType productType = ProductTypeFixtures.defaultProductType(client); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of().price(PRICE).build(); final String slugEn = "referenceable-product-2"; final ProductDraft productDraft = ProductDraftBuilder.of(productType, en("referenceable product"), en(slugEn), variantDraft).build(); return client.executeBlocking(ProductQuery.of().bySlug(ProductProjectionType.STAGED, ENGLISH, slugEn)).head() .orElseGet(() -> client.executeBlocking(ProductCreateCommand.of(productDraft))); }
@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 productType() throws Exception { final Consumer<Product> user = product -> { final Query<Product> query = ProductQuery.of(). bySlug(ProductProjectionType.CURRENT, Locale.ENGLISH, englishSlugOf(product.getMasterData().getStaged())). withExpansionPaths(ProductExpansionModel.of().productType()). toQuery(); final PagedQueryResult<Product> queryResult = client().executeBlocking(query); final Reference<ProductType> productTypeReference = queryResult.head().get().getProductType(); assertThat(productTypeReference).is(expanded()); }; withProduct(client(), "productTypeReferenceExpansion", user); }
@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); }); }