How to use

ProductQueryModel

in

io.sphere.sdk.products.queries

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

public static ProductQueryModel of() {
  return new ProductQueryModel(null, null);
}

ProductQueryImpl(){
  super(ProductEndpoint.ENDPOINT.endpoint(), ProductQuery.resultTypeReference(), ProductQueryModel.of(), ProductExpansionModel.of(), ProductQueryImpl::new);
}

  default ProductQuery bySku(final String sku, final ProductProjectionType type) {
    final QueryPredicate<PartialProductVariantQueryModel> skuPredicate = PartialProductVariantQueryModel.of().sku().is(sku);
    final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type);
    final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate);
    final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate);
    return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate));
  }
}

default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) {
  return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug));
}

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

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

@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 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 ProductQueryModel model() {
  return ProductQueryModel.get();
}

@Test
public void transitionState() {
  withStateByBuilder(client(), builder -> builder.type(PRODUCT_STATE), state -> {
    withUpdateableProduct(client(), product -> {
      assertThat(product.getState()).isNull();
      final Product updatedProduct = client().executeBlocking(ProductUpdateCommand.of(product, asList(TransitionState.of(state))));
      assertThat(updatedProduct.getState()).isEqualTo(state.toReference());
      assertEventually(() -> {
        final PagedQueryResult<ProductStateTransitionMessage> messageQueryResult =
            client().executeBlocking(MessageQuery.of()
                .withPredicates(m -> m.resource().is(product))
                .forMessageType(ProductStateTransitionMessage.MESSAGE_HINT));
        assertThat(messageQueryResult.getResults()).isNotEmpty();
        final ProductStateTransitionMessage message = messageQueryResult.head().get();
        assertThat(message.getState()).isEqualTo(state.toReference());
      });
      //check query model
      final ProductQuery query = ProductQuery.of()
          .withPredicates(m -> m.id().is(product.getId()).and(m.state().is(state)));
      final Product productByState = client().executeBlocking(query)
          .head().get();
      assertThat(productByState).isEqualTo(updatedProduct);
      return updatedProduct;
    });
  });
}

  private ProductQuery query(final Product product) {
    return ProductQuery.of().withPredicates(m -> m.id().is(product.getId()));
  }
}

  default ProductQuery bySku(final String sku, final ProductProjectionType type) {
    final QueryPredicate<EmbeddedProductVariantQueryModel> skuPredicate = EmbeddedProductVariantQueryModel.of().sku().is(sku);
    final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type);
    final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate);
    final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate);
    return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate));
  }
}

default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) {
  return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug));
}

@Test
public void queryProductsWithAnyDiscount() throws Exception {
  withUpdateableProductDiscount(client(), (ProductDiscount productDiscount, Product product) -> {
    final ProductQuery query = ProductQuery.of()
        .withPredicates(m -> m.id().is(product.getId())
            .and(m.masterData().staged().masterVariant().prices().discounted().isPresent()));
    final Duration maxWaitTime = Duration.ofMinutes(2);
    final Duration waitBeforeRetry = Duration.ofMillis(500);
    assertEventually(maxWaitTime, waitBeforeRetry, () -> {
      final Optional<Product> loadedProduct = client().executeBlocking(query).head();
      assertThat(loadedProduct.isPresent()).isTrue();
      assertThat(loadedProduct.get().getId()).isEqualTo(product.getId());
    });
    return productDiscount;
  });
}

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

public static ProductQueryModel model() {
  return ProductQueryModel.get();
}

private CompletionStage<List<Product>> findNext(final ProductQuery seedQuery, final ProductQuery query, final List<Product> products) {
  final CompletionStage<PagedQueryResult<Product>> pageResult = sphereClient().execute(query);
  return pageResult.thenCompose(page -> {
    final List<Product> results = page.getResults();
    products.addAll(results);
    final boolean isLastQueryPage = results.size() < PAGE_SIZE;
    if (isLastQueryPage) {
      return CompletableFuture.completedFuture(products);
    } else {
      final String lastId = getIdForNextQuery(page);
      return findNext(seedQuery, seedQuery
          .plusPredicates(m -> m.id().isGreaterThan(lastId)), products);
    }
  });
}

  default ProductQuery bySku(final String sku, final ProductProjectionType type) {
    final QueryPredicate<EmbeddedProductVariantQueryModel> skuPredicate = EmbeddedProductVariantQueryModel.of().sku().is(sku);
    final ProductDataQueryModel<Product> projection = ProductQueryModel.of().masterData().forProjection(type);
    final QueryPredicate<Product> masterVariantSkuPredicate = projection.masterVariant().where(skuPredicate);
    final QueryPredicate<Product> variantsSkuPredicate = projection.variants().where(skuPredicate);
    return withPredicates(masterVariantSkuPredicate.or(variantsSkuPredicate));
  }
}

default ProductQuery bySlug(final ProductProjectionType type, final Locale locale, final String slug) {
  return withPredicates(m -> m.masterData().forProjection(type).slug().lang(locale).is(slug));
}