/** * Finds all variants that match the search criteria used in the search request, if any. * @return the list containing all matching variants */ default List<ProductVariant> findMatchingVariants() { return getAllVariants().stream() .filter(v -> Optional.ofNullable(v.isMatchingVariant()).orElse(false)) .collect(Collectors.toList()); }
/** * Finds a variant by SKU. * @param sku the sku for the variant * @return Optional of the found variant */ default Optional<ProductVariant> findVariantBySku(final String sku) { Objects.requireNonNull(sku); return getAllVariants().stream().filter(v -> sku.equals(v.getSku())).findFirst(); }
/** * Finds a variant by SKU. * @param sku the sku for the variant * @return Optional of the found variant */ default Optional<ProductVariant> findVariantBySku(final String sku) { Objects.requireNonNull(sku); return getAllVariants().stream().filter(v -> sku.equals(v.getSku())).findFirst(); }
/** * Finds all variants that match the search criteria used in the search request, if any. * @return the list containing all matching variants */ default List<ProductVariant> findMatchingVariants() { return getAllVariants().stream() .filter(v -> Optional.ofNullable(v.isMatchingVariant()).orElse(false)) .collect(Collectors.toList()); }
/** * Finds all variants that match the search criteria used in the search request, if any. * @return the list containing all matching variants */ default List<ProductVariant> findMatchingVariants() { return getAllVariants().stream() .filter(v -> Optional.ofNullable(v.isMatchingVariant()).orElse(false)) .collect(Collectors.toList()); }
/** * Finds a variant by SKU. * @param sku the sku for the variant * @return Optional of the found variant * @deprecated use {@link #findVariantBySku(String)} instead */ @Deprecated default Optional<ProductVariant> findVariantBySky(final String sku) { Objects.requireNonNull(sku); return getAllVariants().stream().filter(v -> sku.equals(v.getSku())).findFirst(); }
/** * Finds a variant by SKU. * @param sku the sku for the variant * @return Optional of the found variant */ default Optional<ProductVariant> findVariantBySku(final String sku) { Objects.requireNonNull(sku); return getAllVariants().stream().filter(v -> sku.equals(v.getSku())).findFirst(); }
protected List<String> attributeCombination(final String attributeKey, final Attribute fixedAttribute, final ProductProjection product) { return product.getAllVariants().stream() .filter(variant -> variant.getAttribute(attributeKey) != null) .filter(variant -> { final Attribute variantAttribute = variant.getAttribute(fixedAttribute.getName()); return variantAttribute != null && variantAttribute.equals(fixedAttribute); }) .map(variant -> attributeValue(variant.getAttribute(attributeKey), userContext.locales(), productDataConfig.getMetaProductType())) .distinct() .collect(toList()); } }
protected void fillAttributeCombinations(final SelectableProductAttributeBean bean, final Attribute attribute, final ProductProjection product) { final List<FormSelectableOptionBean> formOption = new ArrayList<>(); final Map<String, Map<String, List<String>>> selectableData = new HashMap<>(); product.getAllVariants().stream() .map(variant -> variant.getAttribute(attribute.getName())) .filter(attrOption -> attrOption != null) .distinct() .forEach(attrOption -> { final String attrOptionValue = attributeValue(attrOption, userContext.locales(), productDataConfig.getMetaProductType()); formOption.add(createFormOption(attribute, attrOption, attrOptionValue)); selectableData.put(attrOptionValue, createAllowedAttributeCombinations(attrOption, product)); }); bean.setList(formOption); bean.setSelectData(selectableData); }
@Test public void skuExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySku(SKU1); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results.size()).isEqualTo(1); assertThat(results.get(0).getAllVariants().stream().anyMatch(variant -> SKU1.equals(variant.getSku()))).isEqualTo(true); }); }
private Condition<ProductProjection> productWithMatchingVariantsHavingMaxSize() { final Predicate<ProductProjection> matchingVariantsHaveMaxSize = product -> { final long productMaximumSize = product.getAllVariants().stream() .mapToLong(variant -> variant.findAttribute(SIZE_ATTRIBUTE_ACCESS).orElse(0L)) .max() .getAsLong(); return product.findMatchingVariants().stream() .mapToLong(variant -> variant.findAttribute(SIZE_ATTRIBUTE_ACCESS).get()) .allMatch(size -> size == productMaximumSize); }; return new Condition<>(matchingVariantsHaveMaxSize, "all matching variants have maximum size"); }
final List<EnumValue> allVariantsSizeValues = productProjection.getAllVariants() .stream() .map(variant -> variant.getAttribute(sizeAttributeName).getValueAsEnumValue()) final Integer variantIdOfSizeX = productProjection.getAllVariants().get(2).getId(); final ChangeMasterVariant updateAction = ChangeMasterVariant.ofVariantId(variantIdOfSizeX); assertThat(newMasterVariant) .as("third variant is now the master variant") .isEqualTo(productProjection.getAllVariants().get(2)); assertThat(newMasterVariant.getAttribute(sizeAttributeName).getValueAsEnumValue()) .isEqualTo(Sizes.X); final List<EnumValue> reorderedVariantsSizeValues = productProjectionWithNewMasterVariant.getAllVariants() .stream() .map(variant -> variant.getAttribute(sizeAttributeName).getValueAsEnumValue())
@Test public void findMatchingVariantByFulltextSearch() throws Exception { final Condition<ProductVariant> allMatchingVariants = new Condition<>(variant -> variant.isMatchingVariant(), "all are matching variants"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().withMarkingMatchingVariants(true).withText(ENGLISH, "shoe"); assertThat(executeSearch(search).getResults()) .flatExtracting(p -> p.getAllVariants()) .are(allMatchingVariants); }
@Test public void changeMasterVariantWithSku() { withUpdateableProductProjectionOfMultipleVariants(client(), (ProductProjection productProjection) -> { final int originalMasterVariantId = productProjection.getMasterVariant().getId(); final ProductVariant variantSupposedToBeMaster = productProjection.getAllVariants().get(2); final String sku = variantSupposedToBeMaster.getSku(); final ChangeMasterVariant updateAction = ChangeMasterVariant.ofSku(sku); client().executeBlocking(ProductUpdateCommand.of(productProjection, updateAction)); final ProductProjection productProjectionWithNewMasterVariant = client().executeBlocking(ProductProjectionByIdGet.of(productProjection, STAGED)); assertThat(productProjectionWithNewMasterVariant.getMasterVariant().getSku()).isEqualTo(sku); assertThat(productProjectionWithNewMasterVariant.getMasterVariant().getId()) .as("variant IDs don't change in reordering") .isNotEqualTo(originalMasterVariantId) .isEqualTo(variantSupposedToBeMaster.getId()); return productProjectionWithNewMasterVariant; }); }