How to use

of

method

in

io.sphere.sdk.products.queries.ProductQueryModel

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

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

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

@Test
public void variants() throws Exception {
  assertThat(ProductQueryModel.of().masterData().current().variants().sku().is("bar").toSphereQuery())
      .isEqualTo("masterData(current(variants(sku=\"bar\")))");
}

@Test
public void pure() throws Exception {
  final QueryPredicate<Product> purePredicate = ProductQueryModel.of().masterData().current().name().lang(ENGLISH).is("Yes");
  assertThat(purePredicate.toSphereQuery()).isEqualTo("masterData(current(name(en=\"Yes\")))");
}

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

@Test
public void allVariantsInProduct() throws Exception {
  assertThat(ProductQueryModel.of().masterData().current().allVariants().where(m -> m.sku().is("bar")))
      .isEqualTo(ProductQueryModel.of().masterData().current().where(m -> m.masterVariant().sku().is("bar").or(m.variants().sku().is("bar"))))
      .isEqualTo(QueryPredicate.<Product>of(embeddedProductPredicate));
}

  @Override
  public Query<Product> get() {
    final QueryPredicate<Product> predicate = ProductQueryModel.of().
        masterData().current().name().lang(Locale.ENGLISH).is("simple cotton t-shirt");
    return ProductQuery.of().withPredicates(predicate);
  }
}

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 combinedEmbeddedQueries() throws Exception {
    final QueryPredicate<EmbeddedProductDataQueryModel> predicate =
        DATA_QUERY_MODEL.name().lang(ENGLISH).is("Yes").or(DATA_QUERY_MODEL.name().lang(GERMAN).is("Ja"));
    final QueryPredicate<Product> resultPredicate = ProductQueryModel.of().masterData().where(m -> m.current().where(predicate).and(m.staged().where(predicate)));
    assertThat(resultPredicate.toSphereQuery()).isEqualTo("masterData(current(name(en=\"Yes\") or name(de=\"Ja\")) and staged(name(en=\"Yes\") or name(de=\"Ja\")))");
  }
}