0

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

如果我在购物车中有 2*X 符合条件的产品,则预期行为是获得 2*Y 免费产品。

我的问题是多次解雇该促销活动。如果我将多重射击的最大计数设置为 4,那么尽管我在购物车中有 2*X 产品,但动作(获得免费产品)会被激活 4 次。

所以我的结论是,我需要消费符合条件的产品(该产品的条目),比如用户获得的免费产品被消费,因此他们无法参与另一次促销的资格。

我的研究结论是我需要消耗 (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;
    }
}
4

2 回答 2

1

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

只要满足条件,最大规则执行次数允许您控制可以执行规则操作的最大次数。对于所有开箱即用的促销操作,此属性的值应设置为 1。

查看 RuleConfigurationRRD 属性。

取自 help.hybris.com。

于 2017-05-29T23:41:25.540 回答
1

你在哪个版本?在 6.4 或 6.3 AFAIK 之前的免费礼物操作中有一个错误。免费礼物行动由 2 个内部行动组成(将产品添加到购物车并为添加的产品提供 100% 的折扣)。由于该错误,您可能必须将最大规则执行次数增加到原来的两倍(因为每个操作“添加到购物车”和“折扣产品”都将计为一次执行)。

回答您关于订单输入消费的突出问题:促销引擎目前不支持订单输入消费OOTB。此功能是旧促销活动的一部分,但已被放弃以支持可堆叠性。

但更一般地说,您似乎采取的方法并不是 hybris 打算如何使用免费礼物行动。如果您想要 BOGOF(或 BXGYF),您通常会定义一个促销活动,检查您的合格产品X 和要打折的产品Y在购物车中的数量是否足够。然后,该操作将简单地打折Y产品。您还可以添加仅针对产品X的潜在促销检查,这将触发消息,例如将 n 个产品 Y 添加到您的购物车以免费获取它们,以提醒客户她/他有资格获得促销。

如果您查看promotionenginesamplesaddon扩展/插件,您会发现这两个促销应该完全符合我上面的意思:

potential_product_buy_x_get_y_free
product_buy_x_get_y_free

希望这可以帮助,

塞巴斯蒂安

于 2017-05-31T15:02:46.503 回答