How to use

productType

method

in

io.sphere.sdk.products.queries.ProductQueryModel

default ProductQuery byProductType(final Referenceable<ProductType> productType) {
  return withPredicates(m -> m.productType().is(productType));
}

default ProductQuery byProductType(final Referenceable<ProductType> productType) {
  return withPredicates(m -> m.productType().is(productType));
}

default ProductQuery byProductType(final Referenceable<ProductType> productType) {
  return withPredicates(m -> m.productType().is(productType));
}

public QueryDsl<Product> byProductType(final Referenceable<ProductType> productType) {
  return withPredicate(model().productType().is(productType));
}

public QueryDsl<Product> byProductType(final Referenceable<ProductType> productType) {
  return withPredicate(model().productType().is(productType));
}

@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 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);
  }
}

@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)));
  }
}