public static Unpublish of() { return new Unpublish(); } }
private static Product unpublishWithRetry(final BlockingSphereClient client, final Versioned<Product> product, final int ttl) { if (ttl > 0) { try { return client.executeBlocking(ProductUpdateCommand.of(product, Unpublish.of())); } catch(final ConcurrentModificationException e) { final Versioned<Product> versioned = Versioned.of(product.getId(), e.getCurrentVersion()); return unpublishWithRetry(client, versioned, ttl - 1); } } else { throw new RuntimeException("cannot unpublish product due to too much concurrent updates, product: " + product); } }
@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; }); }
public static Unpublish of() { return new Unpublish(); } }
@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 Unpublish of() { return new Unpublish(); } }
private void unpublishAndDelete(final Product product) { client().executeBlocking(ProductDeleteCommand.of(client().executeBlocking(ProductUpdateCommand.of(product, Unpublish.of())))); } }
public static Unpublish of() { return new Unpublish(); } }
final Product unpublishedProduct = client().executeBlocking(ProductUpdateCommand.of(publishedProduct, Unpublish.of()));
public static Unpublish of() { return new Unpublish(); } }
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); } }
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 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; }); } }