public ProductVariantDraftBuilder sku(final String sku) { return sku(Optional.ofNullable(sku)); }
public ProductVariantDraftBuilder sku(final String sku) { return sku(Optional.ofNullable(sku)); }
public ProductVariantDraftDsl withSku(@Nullable final String sku) { return newBuilder().sku(sku).build(); }
@Test public void createsWithAllVariants() { final List<ProductVariantDraft> allVariants = IntStream.range(0, 9) .mapToObj(i -> ProductVariantDraftBuilder.of().sku("sku-" + i).build()) .collect(toList()); final Reference<ProductType> productType = ProductType.referenceOfId("product-type-id"); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), allVariants).build(); assertThat(productDraft.getMasterVariant().getSku()).isEqualTo("sku-0"); assertThat(productDraft.getVariants().get(3).getSku()).isEqualTo("sku-4"); }
@Test public void ofTemplateShouldCopyAllProperties() throws Exception { final ProductVariantDraftDsl template = ProductVariantDraftBuilder.of() .attributes(Collections.emptyList()) .assets(Collections.emptyList()) .key(randomString()) .sku(randomString()) .prices(Collections.emptyList()) .build(); final ProductVariantDraftDsl copy = ProductVariantDraftBuilder.of(template).build(); assertThat(copy).isEqualTo(template); }
private ProductVariantDraft variantDraft() { final AttributeDraft attributeDraft = AttributeDraft.of(ATTR_NAME, AttributeAccess.ofLocalizedEnumValueSet(), new HashSet<>(ALL_ATTRIBUTE_VALUES)); return ProductVariantDraftBuilder.of() .attributes(attributeDraft) .sku(randomKey()) .build(); }
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 withProductWithImages(final BlockingSphereClient client, final List<String> imageUrls, final Function<Product, Product> productProductFunction) { withUpdateableProduct(client, builder -> { final List<Image> imagesList = new LinkedList<>(); for (final String imageUrl : imageUrls) { imagesList.add(Image.ofWidthAndHeight(imageUrl, 460, 102, "commercetools logo")); } final ProductVariantDraft oldMasterVariant = builder.getMasterVariant(); final ProductVariantDraftBuilder variantDraftBuilder = ProductVariantDraftBuilder.of(oldMasterVariant); variantDraftBuilder.images(imagesList); variantDraftBuilder.sku(randomKey()); return builder.masterVariant(variantDraftBuilder.build()); }, productProductFunction); }
public static void withProductHavingAssets(final BlockingSphereClient client, final UnaryOperator<Product> op) { withUpdateableProduct(client, productDraftBuilder -> { final ProductVariantDraft masterVariant = productDraftBuilder.getMasterVariant(); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of(masterVariant) .assets(asList(getAssetDraft1(), getAssetDraft2())) .sku(randomKey()) .build(); return productDraftBuilder.masterVariant(variantDraft); }, op); } public static void withProductHavingImages(final BlockingSphereClient client, final UnaryOperator<Product> op) {
private void withProductOfSku(final String sku, final Function<Product, Product> productProductFunction) { withUpdateableProduct(client(), builder -> { return builder.masterVariant(ProductVariantDraftBuilder.of(builder.getMasterVariant()).sku(sku).build()); }, product -> { final ProductUpdateCommand productUpdateCommand = ProductUpdateCommand.of(product, Publish.of()); final Product publishedProduct = client().executeBlocking(productUpdateCommand); return productProductFunction.apply(publishedProduct); }); }
public static void withUpdateableProductOfMultipleVariants(final BlockingSphereClient client, final Function<Product, Versioned<Product>> f) { withProductType(client, randomKey(), productType -> { final AttributeDraft greenColor = AttributeDraft.of(TShirtProductTypeDraftSupplier.Colors.ATTRIBUTE, TShirtProductTypeDraftSupplier.Colors.GREEN); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(AttributeDraft.of(TShirtProductTypeDraftSupplier.Sizes.ATTRIBUTE, TShirtProductTypeDraftSupplier.Sizes.M), greenColor) .sku(randomKey()) .build(); final List<ProductVariantDraft> variants = Stream.of(TShirtProductTypeDraftSupplier.Sizes.S, TShirtProductTypeDraftSupplier.Sizes.X) .map(size -> AttributeDraft.of(TShirtProductTypeDraftSupplier.Sizes.ATTRIBUTE, size)) .map(attrDraft -> ProductVariantDraftBuilder.of() .attributes(attrDraft, greenColor) .sku(randomKey()) .build()) .collect(toList()); final ProductDraftBuilder builder = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant) .variants(variants); final ProductDraft productDraft = builder.build(); final Product product = client.executeBlocking(ProductCreateCommand.of(productDraft)); Versioned<Product> productToDelete = f.apply(product); client.executeBlocking(ProductDeleteCommand.of(productToDelete)); }); }
@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); }
public static void withProductHavingImages(final BlockingSphereClient client, final UnaryOperator<Product> op) { withUpdateableProduct(client, productDraftBuilder -> { final ProductVariantDraft masterVariant = productDraftBuilder.getMasterVariant(); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of(masterVariant) .images(createExternalImage()) .sku(randomKey()) .build(); return productDraftBuilder.masterVariant(variantDraft); }, op); }
@Test public void sku() { checkFilter(builder -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of(builder.getMasterVariant()) .sku("sku-test-" + randomKey()) .build(); return builder.masterVariant(masterVariant); }, m -> m.allVariants().sku()); }
@Override public ProductDraft get() { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(Sizes.ATTRIBUTE.draftOf(Sizes.S), Colors.ATTRIBUTE.draftOf(Colors.GREEN)) .sku(UUID.randomUUID().toString()) .build(); final LocalizedString slug = en(name).slugifiedUnique(); return ProductDraftBuilder.of(productType, en(name), slug, masterVariant) .description(en(name)) .metaTitle(en("cotton t-shirt")) .metaDescription(en("cotton t-shirt description")) .metaKeywords(en("cotton, t-shirt, clothes")) .build(); }
private static Product createEvilTestProduct(final ProductType productType, final String germanName, final String evilValue, final String sku) { final LocalizedString name = LocalizedString.of(GERMAN, germanName); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(AttributeDraft.of(ATTR_NAME_EVIL, evilValue)) .sku(sku) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, name, name.slugifiedUnique(), masterVariant).build(); return client().executeBlocking(ProductCreateCommand.of(productDraft)); } }
@Override public ProductDraft get() { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(Sizes.ATTRIBUTE.draftOf(Sizes.S), Colors.ATTRIBUTE.draftOf(Colors.GREEN)) .sku(UUID.randomUUID().toString()) .prices(PriceDraft.of(MoneyImpl.ofCents(1234, EUR))) .build(); final ProductVariantDraft secondVariant = ProductVariantDraftBuilder.of() .attributes(Sizes.ATTRIBUTE.draftOf(Sizes.M), Colors.ATTRIBUTE.draftOf(Colors.GREEN)) .sku(UUID.randomUUID().toString()) .prices(PriceDraft.of(MoneyImpl.ofCents(1234, EUR)), PriceDraft.of(MoneyImpl.ofCents(600, EUR)).withCustomerGroup(customerGroup)) .build(); final LocalizedString slug = en(name).slugifiedUnique(); return ProductDraftBuilder.of(productType, en(name), slug, masterVariant) .variants(asList(secondVariant)) .description(en(name)) .metaTitle(en("cotton t-shirt")) .metaDescription(en("cotton t-shirt description")) .metaKeywords(en("cotton, t-shirt, clothes")) .build(); }
private void checkFilter(final UnaryOperator<ProductDraftBuilder> productDraftBuilderUnaryOperator, final Function<ProductProjectionFilterSearchModel, ExistsAndMissingFilterSearchModelSupport<ProductProjection>> dsl) { withProduct(client(), productDraftBuilderUnaryOperator, productWith -> { withProduct(client(), builder -> builder.masterVariant(ProductVariantDraftBuilder.of(builder.getMasterVariant()).sku(null).build()), productWithout -> { assertThat(productWithout.getMasterData().getStaged().getMasterVariant().getSku()).as("sku for productWithout is missing").isNull(); final ProductProjectionSearch baseRequest = ProductProjectionSearch.ofStaged() .withQueryFilters(m -> { final List<String> productIds = asList(productWith.getId(), productWithout.getId()); return m.id().isIn(productIds); }); final ProductProjectionSearch exists = baseRequest.plusQueryFilters(m -> dsl.apply(m).exists()); final ProductProjectionSearch missing = baseRequest.plusQueryFilters(m -> dsl.apply(m).missing()); assertEventually(() -> { assertThat(client().executeBlocking(exists).getResults()).hasSize(1).extracting(s -> s.getId()).as("exists").containsExactly(productWith.getId()); assertThat(client().executeBlocking(missing).getResults()).hasSize(1).extracting(s -> s.getId()).as("missing").containsExactly(productWithout.getId()); }); }); }); } }
private static Product createTestProduct(final ProductType productType, final String germanName, final String englishName, final String color, final int size1, final int size2, final String sku, final String slug) { final LocalizedString name = LocalizedString.of(GERMAN, germanName, ENGLISH, englishName); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(AttributeDraft.of(ATTR_NAME_SIZE, size1), AttributeDraft.of(ATTR_NAME_COLOR, color)) .price(PriceDraft.of(new BigDecimal("23.45"), EUR)) .sku(sku) .key(slug + "-master-variant-key") .build(); final ProductVariantDraft variant = ProductVariantDraftBuilder.of() .attributes(AttributeDraft.of(ATTR_NAME_SIZE, size2)) .price(PriceDraft.of(new BigDecimal("27.45"), EUR)) .key(slug + "-variant2-key") .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, name, LocalizedString.of(ENGLISH, slug), masterVariant) .plusVariants(variant) .key(slug + "-product-key") .build(); return client().executeBlocking(ProductCreateCommand.of(productDraft)); }
public static Product createProduct2(final BlockingSphereClient client, final Referenceable<Product> referencedProductA, final Referenceable<Product> referencedProductB, final Referenceable<ProductType> productTypeReferenceable) { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes( AttributeAccess.ofBoolean().ofName(ATTR_NAME_BOOLEAN).draftOf(false), AttributeAccess.ofText().ofName(ATTR_NAME_TEXT).draftOf(TEXT_BAR), AttributeAccess.ofLocalizedString().ofName(ATTR_NAME_LOC_TEXT).draftOf(LOC_TEXT_BAR), AttributeAccess.ofEnumValue().ofName(ATTR_NAME_ENUM).draftOf(ENUM_THREE), AttributeAccess.ofLocalizedEnumValue().ofName(ATTR_NAME_LOC_ENUM).draftOf(LOC_ENUM_THREE), AttributeAccess.ofDouble().ofName(ATTR_NAME_NUMBER).draftOf(NUMBER_10.doubleValue()), AttributeAccess.ofMoney().ofName(ATTR_NAME_MONEY).draftOf(MONEY_1000_USD), AttributeAccess.ofDate().ofName(ATTR_NAME_DATE).draftOf(DATE_2002), AttributeAccess.ofTime().ofName(ATTR_NAME_TIME).draftOf(TIME_23H), AttributeAccess.ofDateTime().ofName(ATTR_NAME_DATE_TIME).draftOf(DATE_TIME_2002_23H), AttributeAccess.ofProductReference().ofName(ATTR_NAME_REF).draftOf(referencedProductB.toReference()), AttributeAccess.ofBooleanSet().ofName(ATTR_NAME_BOOLEAN_SET).draftOf(asSet(true)), AttributeAccess.ofStringSet().ofName(ATTR_NAME_TEXT_SET).draftOf(asSet(TEXT_FOO)), AttributeAccess.ofLocalizedStringSet().ofName(ATTR_NAME_LOC_TEXT_SET).draftOf(asSet(LOC_TEXT_FOO)), AttributeAccess.ofEnumValueSet().ofName(ATTR_NAME_ENUM_SET).draftOf(asSet(ENUM_TWO)), AttributeAccess.ofLocalizedEnumValueSet().ofName(ATTR_NAME_LOC_ENUM_SET).draftOf(asSet(LOC_ENUM_TWO)), AttributeAccess.ofDoubleSet().ofName(ATTR_NAME_NUMBER_SET).draftOf(asSet(NUMBER_5.doubleValue())), AttributeAccess.ofMoneySet().ofName(ATTR_NAME_MONEY_SET).draftOf(asSet(MONEY_500_EUR)), AttributeAccess.ofDateSet().ofName(ATTR_NAME_DATE_SET).draftOf(asSet(DATE_2001)), AttributeAccess.ofTimeSet().ofName(ATTR_NAME_TIME_SET).draftOf(asSet(TIME_22H)), AttributeAccess.ofDateTimeSet().ofName(ATTR_NAME_DATE_TIME_SET).draftOf(asSet(DATE_TIME_2001_22H)), AttributeAccess.ofProductReferenceSet().ofName(ATTR_NAME_REF_SET).draftOf(asSet(referencedProductA.toReference()))) .price(PriceDraft.of(new BigDecimal("46.80"), USD)) .sku(SKU2) .build(); return createTestProduct(client, "Product two", masterVariant, productTypeReferenceable); }