Question

我已实施BXGY自定义促销。为了简化我的情况，我们假设您在购物车中装有X产品后，您将获得免费产品。

如果我在购物车中有2 * X合格产品，预期行为是获得2 * Y免费产品。

我的问题是多次触发促销活动。如果我将多重射击的最大数量设置为4，则动作（获得免费产品）被激活4次，尽管我在购物车中有2 * X个产品。

所以我的结论是，我需要使用符合条件的产品（使用该产品的条目），例如用户获得的免费产品，因此他们无法参与其他促销的资格。

我的研究结论是我需要在（YFreeGift）RAOAction中使用条目，但是我需要检索所有有条件的产品而我不觉得它是正确的方式（条件在起作用）

有人知道如何使用符合条件的条目吗？

BXGY的条件翻译（我也有强制性的合格产品，但对这个问题并不重要）

public class RuleHeinekenBXGYFQualifyingProductsConditionTranslator implements RuleConditionTranslator
{
    @Override
    public RuleIrCondition translate(RuleCompilerContext context, RuleConditionData ruleCondition, RuleConditionDefinitionData conditionDefinition) throws RuleCompilerException
    {
        List<String> mandatoryProducts = (List) getConditionParameterValue(ruleCondition, "mandatoryQualifyingProducts");
        List<String> alternativeProducts = (List) getConditionParameterValue(ruleCondition, "alternativeQualifyingProducts");
        Integer qualifyingCount = (Integer) getConditionParameterValue(ruleCondition, "qualifyingCount");

        if(isEmpty(mandatoryProducts) && isEmpty(alternativeProducts) || qualifyingCount == null || qualifyingCount <= 0)
            throw new PromotionConditionParametersValidationException();

        String cartRAO = context.generateVariable(CartRAO.class);
        List<RuleIrCondition> mandatoryProductsConditions = getMandatoryProductsConditions(context, mandatoryProducts, cartRAO);
        List<RuleIrCondition> qualifyingCountCondition = getQualifyingCountCondition(context, qualifyingCount, cartRAO);

        RuleIrGroupCondition qualifyingConditions = new RuleIrGroupCondition();
        qualifyingConditions.setOperator(RuleIrGroupOperator.AND);
        qualifyingConditions.setChildren(listUnion(mandatoryProductsConditions, qualifyingCountCondition));
        return qualifyingConditions;
    }

    private List<RuleIrCondition> getQualifyingCountCondition(RuleCompilerContext context, Integer qualifyingCount, String cartRAO)
    {
        String qualifyingCountRAO = context.generateVariable(QualifyingCountRAO.class);
        String promotionCode = context.getRule().getCode();

        return getListOfRuleConditions(
            aRuleCondition()
                .withModelRAO(qualifyingCountRAO)
                .withAttribute("promotionCode")
                .withOperator(EQUAL)
                .withValue(promotionCode)
                .buildAttributeCondition(),

            aRuleCondition()
                .withModelRAO(qualifyingCountRAO)
                .withAttribute("qualifyingCount")
                .withOperator(GREATER_THAN_OR_EQUAL)
                .withValue(qualifyingCount)
                .buildAttributeCondition(),

            aRuleCondition()
                .withModelRAO(cartRAO)
                .withAttribute("qualifyingCounts")
                .withOperator(CONTAINS)
                .withTargetVariable(qualifyingCountRAO)
                .buildAttributeRelationCondition());
    }

    private List<RuleIrCondition> getMandatoryProductsConditions(RuleCompilerContext context, List<String> mandatoryProducts, String cartRAO)
    {
        if(isEmpty(mandatoryProducts))
            return emptyList();

        return getMapOfQualifyingProductsWithQuantities(mandatoryProducts)
                 .entrySet().stream()
                 .map(entry -> getMandatoryProductCondition(context, cartRAO, entry.getKey(), entry.getValue()))
                 .collect(toList());
    }

    private RuleIrExistsCondition getMandatoryProductCondition(RuleCompilerContext context, String cartRAO, String product, int qualifyingCount)
    {
        RuleIrLocalVariablesContainer variablesContainer = context.createLocalContainer();
        String containsProductRAO = context.generateLocalVariable(variablesContainer, ProductRAO.class);
        String containsOrderEntryRAO = context.generateLocalVariable(variablesContainer, OrderEntryRAO.class);

        List<RuleIrCondition> listOfConditions = getListOfRuleConditions(
            aRuleCondition()
                .withModelRAO(containsProductRAO)
                .withAttribute("code")
                .withOperator(EQUAL)
                .withValue(product)
                .buildAttributeCondition(),

            aRuleCondition()
                .withModelRAO(containsOrderEntryRAO)
                .withAttribute("product")
                .withOperator(EQUAL)
                .withTargetVariable(containsProductRAO)
                .buildAttributeRelationCondition(),

            aRuleCondition()
                .withModelRAO(containsOrderEntryRAO)
                .withAttribute("quantity")
                .withOperator(GREATER_THAN_OR_EQUAL)
                .withValue(qualifyingCount)
                .buildAttributeCondition(),

            aRuleCondition()
                .withModelRAO(cartRAO)
                .withAttribute("entries")
                .withOperator(CONTAINS)
                .withTargetVariable(containsOrderEntryRAO)
                .buildAttributeRelationCondition());

        RuleIrExistsCondition mandatoryProductsExistCondition = new RuleIrExistsCondition();
        mandatoryProductsExistCondition.setVariablesContainer(variablesContainer);
        mandatoryProductsExistCondition.setChildren(listOfConditions);
        return mandatoryProductsExistCondition;
    }
}

Answer 1

规则引擎提供了一种配置限制的机制   规则可以触发操作项的次数。

最大规则执行允许您控制最大数量   只要条件，就可以执行规则的动作   满足了。对于所有开箱即用的促销活动，其价值   属性应设置为1。

查看RuleConfigurationRRD属性。

取自help.hybris.com。

Answer 2

你在哪个版本？在6.4或6.3 AFAIK之前的免费礼品行动中存在错误。免费礼品行动由内部的2个动作组成（将产品添加到购物车并对添加的产品给予100％折扣）。由于该错误，您可能必须将最大规则执行次数增加到原来的数量的两倍（因为每个操作“添加到购物车”和“折扣产品”将计为一次执行）。

回答有关订单输入消费的突出问题： promotionengine目前不支持订单输入消费OOTB。这是一项功能，是旧版促销的一部分，但已被弃用，支持可堆叠性。

但更一般地说，你似乎采取的方法并不是hybris打算如何使用免费赠品。如果您想要BOGOF（或BXGYF），您通常会定义一个促销活动，检查您的合格产品 X AND 待打折产品 Y 是否在购物车中数量充足。然后，该操作将简单地折扣 Y 产品。您还可以添加潜在促销，仅检查产品 X ，该产品会触发将n个产品Y添加到购物车以免费获取等消息，以便提醒他/她有资格获得晋升的客户。

如果您查看 promotionenginesamplesaddon 扩展程序/插件，您会发现这两个促销应该完全符合我的意思：

potential_product_buy_x_get_y_free
product_buy_x_get_y_free

希望这有帮助，

塞巴斯蒂安

多次触发BXGY促销 - 消费合格订单条目

2 个答案: