@pisell/pisellos 2.2.141 → 2.2.143

package/dist/model/strategy/adapter/walletPass/evaluator.js

@@ -24,6 +24,25 @@ var defaultStrategyMetadataCustom = {
   deductOptionPrice: false
 };
 
+/**
+ * 条件 field → reasonCode 映射
+ * 用于将策略引擎返回的 failedField 转换为本地化文案 key
+ */
+var FIELD_REASON_CODE_MAP = {
+  orderTotalAmount: 'order_total_amount_not_enough',
+  applicableProductTotalAmount: 'applicable_product_total_amount_not_enough',
+  applicableProductCount: 'applicable_product_count_not_enough'
+};
+
+/**
+ * 用阈值替换文案中的占位符（同时兼容 ${value} 和 {value}）
+ */
+function formatReason(template, value) {
+  if (!template) return template;
+  var replacement = value === undefined || value === null ? '' : String(value);
+  return template.replace(/\$\{value\}/g, replacement).replace(/\{value\}/g, replacement);
+}
+
 /**
  * Wallet Pass 评估器
  * 用于评估哪些 voucher 可以在当前订单中使用
@@ -191,13 +210,17 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               strategyResult: evaluationResult
             });
           } else {
-            // 根据策略评估结果的 code 映射到 locales 中的原因
-            var reasonCode = 'not_meet_the_required_conditions'; // 默认原因
-
-            // 根据策略引擎返回的 code 映射到本地化的 reasonCode
-            if (evaluationResult.code) {
-              // 可以根据具体的 code 映射到不同的原因
-              // 例如：如果是金额不足、使用次数限制等
+            var _evaluationResult$mat, _evaluationResult$mat2;
+            // 优先根据失败的 field 映射到具体的 reasonCode（更精确的失败原因）
+            var reasonCode = 'not_meet_the_required_conditions';
+            var thresholdValue = undefined;
+            var failedField = (_evaluationResult$mat = evaluationResult.matched) === null || _evaluationResult$mat === void 0 ? void 0 : _evaluationResult$mat.failedField;
+            var failedRule = (_evaluationResult$mat2 = evaluationResult.matched) === null || _evaluationResult$mat2 === void 0 || (_evaluationResult$mat2 = _evaluationResult$mat2.failedRules) === null || _evaluationResult$mat2 === void 0 ? void 0 : _evaluationResult$mat2[0];
+            if (failedField && FIELD_REASON_CODE_MAP[failedField]) {
+              reasonCode = FIELD_REASON_CODE_MAP[failedField];
+              thresholdValue = failedRule === null || failedRule === void 0 ? void 0 : failedRule.value;
+            } else if (evaluationResult.code) {
+              // 兜底：保留原有 code → reasonCode 映射
               var codeMapping = {
                 INSUFFICIENT_AMOUNT: 'not_meet_the_required_conditions',
                 USAGE_LIMIT_EXCEEDED: 'usage_limit_reached',
@@ -207,6 +230,8 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               };
               reasonCode = codeMapping[evaluationResult.code] || 'not_meet_the_required_conditions';
             }
+            var rawText = this.getText(reasonCode);
+            var reason = thresholdValue !== undefined ? formatReason(rawText, thresholdValue) : rawText;
             results.push({
               voucher: voucher,
               isApplicable: false,
@@ -214,7 +239,7 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               maxDeduction: 0,
               deductTaxAndFee: false,
               applicableProductIds: [],
-              reason: this.getText(reasonCode),
+              reason: reason,
               reasonCode: reasonCode,
               strategyResult: evaluationResult
             });

package/dist/model/strategy/adapter/walletPass/locales.js

@@ -5,7 +5,10 @@ export var locales = {
     'usage_limit_reached': '已达到使用次数上限',
     'max_passes_per_item_reached': '该商品已达到卡券使用上限',
     'not_available_for_this_channel': '当前渠道不可使用',
-    'not_valid_for_this_order_type': '当前订单类型不适用'
+    'not_valid_for_this_order_type': '当前订单类型不适用',
+    'order_total_amount_not_enough': '订单满 ${value} 才可用',
+    'applicable_product_total_amount_not_enough': '适用商品满 ${value} 才可用',
+    'applicable_product_count_not_enough': '至少购买 {value} 件适用商品才可用'
   },
   'en': {
     'not_meet_the_required_conditions': 'Not meet the required conditions.',
@@ -13,7 +16,10 @@ export var locales = {
     'usage_limit_reached': 'Usage limit reached.',
     'max_passes_per_item_reached': 'Max passes per item reached.',
     'not_available_for_this_channel': 'Not available for this channel.',
-    'not_valid_for_this_order_type': 'Not valid for this order type.'
+    'not_valid_for_this_order_type': 'Not valid for this order type.',
+    'order_total_amount_not_enough': 'Spend ${value} to use',
+    'applicable_product_total_amount_not_enough': '${value} on eligible items',
+    'applicable_product_count_not_enough': 'Buy {value} eligible items to use'
   },
   'zh-HK': {
     'not_meet_the_required_conditions': '未達使用條件',
@@ -21,6 +27,9 @@ export var locales = {
     'usage_limit_reached': '已達使用次數上限',
     'max_passes_per_item_reached': '該商品已達卡券使用上限',
     'not_available_for_this_channel': '當前渠道不可使用',
-    'not_valid_for_this_order_type': '當前訂單類型不適用'
+    'not_valid_for_this_order_type': '當前訂單類型不適用',
+    'order_total_amount_not_enough': '訂單滿 ${value} 才可用',
+    'applicable_product_total_amount_not_enough': '適用商品滿 ${value} 才可用',
+    'applicable_product_count_not_enough': '至少購買 {value} 件適用商品才可用'
   }
 };

package/dist/model/strategy/engine.d.ts

@@ -27,17 +27,30 @@ export declare class StrategyEngine {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
     private evaluateConditionGroup;
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
+     */
+    private evaluateGroupLogicDetailed;
+    /**
+     * 评估单个规则（带失败规则收集）
+     */
+    private evaluateRuleDetailed;
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
      */
-    private evaluateGroupLogic;
+    private evaluateAtomicRule;
     /**
-     * 评估单个规则
+     * 构建失败规则信息
      */
-    private evaluateRule;
+    private buildFailedRuleInfo;
     /**
      * 评估代码模式条件
      */

package/dist/model/strategy/engine.js

@@ -6,6 +6,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -68,6 +70,7 @@ export var StrategyEngine = /*#__PURE__*/function () {
         errors: []
       };
       try {
+        var _evaluationResult$fai;
         // 验证配置
         this.validateConfig(config);
         if (this.options.enableTrace) {
@@ -125,11 +128,14 @@ export var StrategyEngine = /*#__PURE__*/function () {
           applicable: applicable,
           code: applicable ? SUCCESS_CODES.SUCCESS : NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
           message: applicable ? 'Strategy is applicable' : 'Conditions not met',
-          matched: {
+          matched: _objectSpread({
             conditions: applicable,
             actionIds: evaluationResult.actionIds,
             details: {}
-          },
+          }, applicable ? {} : {
+            failedField: (_evaluationResult$fai = evaluationResult.failedRules[0]) === null || _evaluationResult$fai === void 0 ? void 0 : _evaluationResult$fai.field,
+            failedRules: evaluationResult.failedRules
+          }),
           matchedActions: sortedActions,
           outputs: {},
           config: config
@@ -174,19 +180,18 @@ export var StrategyEngine = /*#__PURE__*/function () {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
   }, {
     key: "evaluateConditionGroup",
     value: function evaluateConditionGroup(group, context) {
       var collectedActionIds = [];
 
-      // 评估当前层的 operator 和 rules
-      var isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-
-      // 如果当前层条件满足
-      if (isCurrentLayerSatisfied) {
-        // 收集当前层的 actionIds
+      // 评估当前层的 operator 和 rules（同时收集失败信息）
+      var _this$evaluateGroupLo = this.evaluateGroupLogicDetailed(group, context),
+        satisfied = _this$evaluateGroupLo.satisfied,
+        failedRules = _this$evaluateGroupLo.failedRules;
+      if (satisfied) {
         collectedActionIds.push.apply(collectedActionIds, _toConsumableArray(group.actionIds));
 
         // 递归评估嵌套的 ConditionGroup，收集嵌套层的 actionIds
@@ -207,54 +212,134 @@ export var StrategyEngine = /*#__PURE__*/function () {
         }
       }
       return {
-        satisfied: isCurrentLayerSatisfied,
-        actionIds: collectedActionIds
+        satisfied: satisfied,
+        actionIds: collectedActionIds,
+        failedRules: failedRules
       };
     }
 
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
      */
   }, {
-    key: "evaluateGroupLogic",
-    value: function evaluateGroupLogic(group, context) {
-      var _this = this;
+    key: "evaluateGroupLogicDetailed",
+    value: function evaluateGroupLogicDetailed(group, context) {
       var operator = group.operator,
         rules = group.rules;
       switch (operator) {
         case 'and':
-          // 所有规则都必须满足
-          return rules.every(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var _iterator2 = _createForOfIteratorHelper(rules),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var rule = _step2.value;
+                var ruleResult = this.evaluateRuleDetailed(rule, context);
+                if (!ruleResult.satisfied) {
+                  return {
+                    satisfied: false,
+                    failedRules: ruleResult.failedRules
+                  };
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         case 'or':
-          // 任一规则满足即可
-          return rules.some(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var aggregated = [];
+            var _iterator3 = _createForOfIteratorHelper(rules),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _rule = _step3.value;
+                var _ruleResult = this.evaluateRuleDetailed(_rule, context);
+                if (_ruleResult.satisfied) {
+                  return {
+                    satisfied: true,
+                    failedRules: []
+                  };
+                }
+                aggregated.push.apply(aggregated, _toConsumableArray(_ruleResult.failedRules));
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            return {
+              satisfied: false,
+              failedRules: aggregated
+            };
+          }
         case 'not':
-          // 对第一个规则取反
-          if (rules.length === 0) return false;
-          return !this.evaluateRule(rules[0], context);
+          {
+            if (rules.length === 0) {
+              return {
+                satisfied: false,
+                failedRules: []
+              };
+            }
+            var _ruleResult2 = this.evaluateRuleDetailed(rules[0], context);
+            if (_ruleResult2.satisfied) {
+              // 被取反规则实际通过，导致 not 失败
+              var failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
+              return {
+                satisfied: false,
+                failedRules: failed
+              };
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         default:
           throw new Error("Unknown operator: ".concat(operator));
       }
     }
 
     /**
-     * 评估单个规则
+     * 评估单个规则（带失败规则收集）
      */
   }, {
-    key: "evaluateRule",
-    value: function evaluateRule(rule, context) {
-      // 如果是嵌套的条件组，递归评估
+    key: "evaluateRuleDetailed",
+    value: function evaluateRuleDetailed(rule, context) {
       if (this.isConditionGroup(rule)) {
-        return this.evaluateGroupLogic(rule, context);
+        return this.evaluateGroupLogicDetailed(rule, context);
       }
-
-      // 原子条件规则
       var conditionRule = rule;
+      var satisfied = this.evaluateAtomicRule(conditionRule, context);
+      if (satisfied) {
+        return {
+          satisfied: true,
+          failedRules: []
+        };
+      }
+      return {
+        satisfied: false,
+        failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+      };
+    }
 
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
+     */
+  }, {
+    key: "evaluateAtomicRule",
+    value: function evaluateAtomicRule(conditionRule, context) {
       // Code 模式：使用 eval 执行
       if (conditionRule.type === 'code' && conditionRule.code) {
         return this.evaluateCodeCondition(conditionRule.code, context);
@@ -264,6 +349,21 @@ export var StrategyEngine = /*#__PURE__*/function () {
       return this.evaluateOperatorCondition(conditionRule, context);
     }
 
+    /**
+     * 构建失败规则信息
+     */
+  }, {
+    key: "buildFailedRuleInfo",
+    value: function buildFailedRuleInfo(conditionRule, context) {
+      var actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : undefined;
+      return {
+        field: conditionRule.field,
+        operator: conditionRule.operator,
+        value: conditionRule.value,
+        actualValue: actualValue
+      };
+    }
+
     /**
      * 评估代码模式条件
      */
@@ -323,11 +423,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       // 支持点号路径，如 "order.total"
       var path = field.split('.');
       var value = context.attributes;
-      var _iterator2 = _createForOfIteratorHelper(path),
-        _step2;
+      var _iterator4 = _createForOfIteratorHelper(path),
+        _step4;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var key = _step4.value;
           if (value && _typeof(value) === 'object' && key in value) {
             value = value[key];
           } else {
@@ -335,9 +435,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator2.f();
+        _iterator4.f();
       }
       return value;
     }
@@ -437,11 +537,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       var actionMap = new Map(actions.map(function (action) {
         return [action.id, action];
       }));
-      var _iterator3 = _createForOfIteratorHelper(actionIds),
-        _step3;
+      var _iterator5 = _createForOfIteratorHelper(actionIds),
+        _step5;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var id = _step3.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var id = _step5.value;
           var action = actionMap.get(id);
           if (action) {
             matchedActions.push(action);
@@ -453,9 +553,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator3.f();
+        _iterator5.f();
       }
       return matchedActions;
     }

package/dist/model/strategy/type.d.ts

@@ -165,6 +165,23 @@ export interface MatchedInfo {
     actionIds: string[];
     /** 详细匹配信息 */
     details: Record<string, any>;
+    /** 顶层第一个失败的 field（仅在 conditions=false 时存在，便于直接消费） */
+    failedField?: string;
+    /** 失败的原子规则列表（仅在 conditions=false 时存在；or 全失败时可能有多条） */
+    failedRules?: FailedRuleInfo[];
+}
+/**
+ * 失败规则信息
+ */
+export interface FailedRuleInfo {
+    /** 字段名 */
+    field?: string;
+    /** 运算符 */
+    operator?: string;
+    /** 配置的比较值（阈值） */
+    value?: any;
+    /** 实际取到的字段值 */
+    actualValue?: any;
 }
 /**
  * 执行轨迹

package/dist/model/strategy/type.js

@@ -51,6 +51,10 @@
  * 匹配信息
  */
 
+/**
+ * 失败规则信息
+ */
+
 /**
  * 执行轨迹
  */

package/dist/server/index.js

@@ -2665,7 +2665,8 @@ var Server = /*#__PURE__*/function () {
                 rawCount: rawList.length,
                 filteredCount: result.count,
                 size: result.size,
-                skip: result.skip
+                skip: result.skip,
+                rejected: result.rejected
               });
               return _context23.abrupt("return", {
                 code: 200,

package/dist/server/modules/index.d.ts

@@ -14,7 +14,7 @@ export { QuotationHooks } from './quotation/types';
 export { ScheduleModuleEx } from './schedule';
 export type { ScheduleState, ScheduleItem } from './schedule/types';
 export { OrderModule } from './order';
-export type { OrderState, OrderData, OrderId, OrderSummary, OrderBookingItem, OrderProductLineItem, OrderPaymentItem, OrderSurchargeItem, OrderProductDiscountItem, OrderWithoutBookings, BookingData, OrderFilters, BookingFilters, OrderFilterResult, BookingFilterResult, OrderModulePagedResult, } from './order/types';
+export type { OrderState, OrderData, OrderId, OrderSummary, OrderBookingItem, OrderProductLineItem, OrderPaymentItem, OrderSurchargeItem, OrderProductDiscountItem, OrderWithoutBookings, BookingData, OrderFilters, BookingFilters, OrderFilterResult, OrderFilterRejectDetail, OrderFilterRejectedEntry, BookingFilterResult, OrderModulePagedResult, } from './order/types';
 export { OrderHooks } from './order/types';
 export { FloorPlanModule } from './floor-plan';
 export type { FloorPlanItem, FloorPlanState, FloorPlanSyncMessage } from './floor-plan/types';

package/dist/server/modules/order/types.d.ts

@@ -479,7 +479,27 @@ export interface OrderModulePagedResult<T> {
     size: number;
     skip: number;
 }
-export type OrderFilterResult = OrderModulePagedResult<OrderData>;
+/** 单条筛选未命中说明（用于排查过滤原因） */
+export interface OrderFilterRejectDetail {
+    /** 对应 OrderFilters 维度的标识 */
+    field: string;
+    /** 订单上该维度的当前值 */
+    actual: unknown;
+    /** 本次筛选的期望值/区间（便于对照） */
+    expected?: unknown;
+}
+/** 未通过筛选的订单及首个未满足条件（与过滤短路顺序一致） */
+export interface OrderFilterRejectedEntry {
+    order_id?: OrderId | null;
+    /** 系统订单号等，便于与业务「订单号」对照 */
+    order_number?: string;
+    /** 按筛选顺序命中的第一条未满足条件 */
+    reason: OrderFilterRejectDetail;
+}
+export type OrderFilterResult = OrderModulePagedResult<OrderData> & {
+    /** 被过滤掉的订单及首个命中原因（与筛选短路顺序一致；不含仅分页未展示的已通过订单） */
+    rejected: OrderFilterRejectedEntry[];
+};
 export type BookingFilterResult = OrderModulePagedResult<BookingData>;
 /**
  * SSE 同步配置

package/dist/server/modules/order/types.js

@@ -111,6 +111,10 @@
 
 /** 分页筛选结果通用结构 */
 
+/** 单条筛选未命中说明（用于排查过滤原因） */
+
+/** 未通过筛选的订单及首个未满足条件（与过滤短路顺序一致） */
+
 /**
  * SSE 同步配置
  */