@Override public Boolean isPublished() { return product.getMasterData().isPublished(); }
@Override public boolean isPublished() { return product.getMasterData().isPublished(); } }
@Override public Boolean isPublished() { return product.getMasterData().isPublished(); }
@Override public Boolean isPublished() { return product.getMasterData().isPublished(); }
@Override public boolean isPublished() { return product.getMasterData().isPublished(); }
@Test public void publish() throws Exception { withUpdateableProduct(client(), product -> { assertThat(product.getMasterData().isPublished()).isFalse(); final Product publishedProduct = client().executeBlocking(ProductUpdateCommand.of(product, Publish.of())); assertThat(publishedProduct.getMasterData().isPublished()).isTrue(); final Product unpublishedProduct = client().executeBlocking(ProductUpdateCommand.of(publishedProduct, Unpublish.of())); assertThat(unpublishedProduct.getMasterData().isPublished()).isFalse(); return unpublishedProduct; }); }
@Test public void isPublished() throws Exception { withUpdateableProduct(client(), product -> { assertThat(product.getMasterData().isPublished()).isFalse(); checkIsFoundByPublishedFlag(product, false); final Product publishedProduct = client().executeBlocking(ProductUpdateCommand.of(product, Publish.of())); assertThat(publishedProduct.getMasterData().isPublished()).isTrue(); checkIsFoundByPublishedFlag(product, true); final Product unpublishedProduct = client().executeBlocking(ProductUpdateCommand.of(publishedProduct, Unpublish.of())); assertThat(unpublishedProduct.getMasterData().isPublished()).isFalse(); return unpublishedProduct; }); }
public static void delete(final BlockingSphereClient client, final Product product) { final Optional<Product> freshLoadedProduct = Optional.ofNullable(client.executeBlocking(ProductByIdGet.of(product.getId()))); freshLoadedProduct.ifPresent(loadedProduct -> { final boolean isPublished = loadedProduct.getMasterData().isPublished(); final Product unPublishedProduct; if (isPublished) { unPublishedProduct = unpublishWithRetry(client, loadedProduct, 5); } else { unPublishedProduct = loadedProduct; } deleteWithRetry(client, unPublishedProduct, 5); }); }
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); } }
@Test public void message() { ProductFixtures.withUpdateableProduct(client(), product -> { assertThat(product.getMasterData().isPublished()).isFalse(); final Product unpublishedProduct = client().executeBlocking(ProductUpdateCommand.of(product, asList(Publish.of(), Unpublish.of()))); assertEventually(() -> { final PagedQueryResult<ProductUnpublishedMessage> queryResult = client().executeBlocking(MessageQuery.of() .withPredicates(m -> m.resource().is(unpublishedProduct)) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(ProductUnpublishedMessage.MESSAGE_HINT)); assertThat(queryResult.head()).isPresent(); final ProductUnpublishedMessage message = queryResult.head().get(); assertThat(message.getResource().getId()).as("productId").isEqualTo(product.getId()); assertThat(message.getResource().getObj().getMasterData().isPublished()).isFalse(); }); return unpublishedProduct; }); } }
@Test public void message() { ProductFixtures.withUpdateableProduct(client(), product -> { assertThat(product.getMasterData().isPublished()).isFalse(); final Product publishedProduct = client().executeBlocking(ProductUpdateCommand.of(product, Publish.of())); Query<ProductPublishedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(product)) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(ProductPublishedMessage.MESSAGE_HINT); assertEventually(() -> { final PagedQueryResult<ProductPublishedMessage> queryResult = client().executeBlocking(messageQuery); assertThat(queryResult.head()).isPresent(); final ProductPublishedMessage message = queryResult.head().get(); assertThat(message.getResource().getId()).isEqualTo(product.getId()); assertThat(message.getProductProjection().getMasterVariant()).isEqualTo(publishedProduct.getMasterData().getCurrent().getMasterVariant()); assertThat(message.getResource().getObj().getMasterData().getCurrent().getSlug()).isEqualTo(message.getProductProjection().getSlug()); assertThat(message.getRemovedImageUrls().size()).isEqualTo(0); }); return publishedProduct; }); } }
public static void withUpdateableProduct(final BlockingSphereClient client, final UnaryOperator<ProductDraftBuilder> builderOp, final Function<Product, Product> f) { withEmptyProductType(client, productType -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().build(); final ProductDraftBuilder builder = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant); final ProductDraft productDraft = builderOp.apply(builder).build(); final Product product = client.executeBlocking(ProductCreateCommand.of(productDraft)); Product productToDelete = f.apply(product); if (productToDelete.getMasterData().isPublished()) { productToDelete = client.executeBlocking(ProductUpdateCommand.of(productToDelete, Unpublish.of())); } delete(client, productToDelete); }); }
@Test public void createPublishedProduct() { withEmptyProductType(client(), randomKey(), productType -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().build(); final LocalizedString name = randomSlug(); final LocalizedString slug = randomSlug(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, name, slug, masterVariant) .publish(true) .build(); final Product product = client().executeBlocking(ProductCreateCommand.of(productDraft)); assertThat(product.getMasterData().isPublished()).isTrue(); assertThat(product.getMasterData().getCurrent().getSlug()).isEqualTo(slug); assertEventually(() -> { final ProductProjectionSearch search = ProductProjectionSearch.ofCurrent() .withQueryFilters(m -> m.id().is(product.getId())); final PagedSearchResult<ProductProjection> searchResult = client().executeBlocking(search); assertThat(searchResult.getResults()).hasSize(1); }); unpublishAndDelete(product); }); }