@pisell/pisellos 2.1.149 → 2.1.151

package/lib/model/strategy/engine.js

@@ -42,7 +42,7 @@ var StrategyEngine = class {
    * 评估策略
    */
   evaluate(config, context) {
-    var _a;
+    var _a, _b;
     const startTime = Date.now();
     const trace = {
       steps: [],
@@ -105,7 +105,11 @@ var StrategyEngine = class {
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
-          details: {}
+          details: {},
+          ...applicable ? {} : {
+            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
+            failedRules: evaluationResult.failedRules
+          }
         },
         matchedActions: sortedActions,
         outputs: {},
@@ -119,7 +123,7 @@ var StrategyEngine = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (this.options.enableTrace) {
-        (_a = trace.errors) == null ? void 0 : _a.push({
+        (_b = trace.errors) == null ? void 0 : _b.push({
           step: "evaluation",
           error: errorMessage,
           timestamp: Date.now()
@@ -149,12 +153,15 @@ var StrategyEngine = class {
    *
    * @param group 条件组
    * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+   * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-    if (isCurrentLayerSatisfied) {
+    const { satisfied, failedRules } = this.evaluateGroupLogicDetailed(
+      group,
+      context
+    );
+    if (satisfied) {
       collectedActionIds.push(...group.actionIds);
       for (const rule of group.rules) {
         if (this.isConditionGroup(rule)) {
@@ -164,41 +171,98 @@ var StrategyEngine = class {
       }
     }
     return {
-      satisfied: isCurrentLayerSatisfied,
-      actionIds: collectedActionIds
+      satisfied,
+      actionIds: collectedActionIds,
+      failedRules
     };
   }
   /**
-   * 评估条件组的逻辑运算
+   * 评估条件组的逻辑运算（带失败规则收集）
+   *
+   * 失败规则收集策略：
+   * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+   * - `or`：所有分支失败时，聚合每个分支的失败规则
+   * - `not`：被取反规则实际通过时，记录该规则
    */
-  evaluateGroupLogic(group, context) {
+  evaluateGroupLogicDetailed(group, context) {
     const { operator, rules } = group;
     switch (operator) {
-      case "and":
-        return rules.every((rule) => this.evaluateRule(rule, context));
-      case "or":
-        return rules.some((rule) => this.evaluateRule(rule, context));
-      case "not":
-        if (rules.length === 0)
-          return false;
-        return !this.evaluateRule(rules[0], context);
+      case "and": {
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (!ruleResult.satisfied) {
+            return {
+              satisfied: false,
+              failedRules: ruleResult.failedRules
+            };
+          }
+        }
+        return { satisfied: true, failedRules: [] };
+      }
+      case "or": {
+        const aggregated = [];
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (ruleResult.satisfied) {
+            return { satisfied: true, failedRules: [] };
+          }
+          aggregated.push(...ruleResult.failedRules);
+        }
+        return { satisfied: false, failedRules: aggregated };
+      }
+      case "not": {
+        if (rules.length === 0) {
+          return { satisfied: false, failedRules: [] };
+        }
+        const ruleResult = this.evaluateRuleDetailed(rules[0], context);
+        if (ruleResult.satisfied) {
+          const 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: ${operator}`);
     }
   }
   /**
-   * 评估单个规则
+   * 评估单个规则（带失败规则收集）
    */
-  evaluateRule(rule, context) {
+  evaluateRuleDetailed(rule, context) {
     if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogic(rule, context);
+      return this.evaluateGroupLogicDetailed(rule, context);
     }
     const conditionRule = rule;
+    const satisfied = this.evaluateAtomicRule(conditionRule, context);
+    if (satisfied) {
+      return { satisfied: true, failedRules: [] };
+    }
+    return {
+      satisfied: false,
+      failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+    };
+  }
+  /**
+   * 评估原子规则（不收集失败信息，仅返回布尔结果）
+   */
+  evaluateAtomicRule(conditionRule, context) {
     if (conditionRule.type === "code" && conditionRule.code) {
       return this.evaluateCodeCondition(conditionRule.code, context);
     }
     return this.evaluateOperatorCondition(conditionRule, context);
   }
+  /**
+   * 构建失败规则信息
+   */
+  buildFailedRuleInfo(conditionRule, context) {
+    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : void 0;
+    return {
+      field: conditionRule.field,
+      operator: conditionRule.operator,
+      value: conditionRule.value,
+      actualValue
+    };
+  }
   /**
    * 评估代码模式条件
    */

package/lib/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/lib/modules/Cart/types.d.ts

@@ -75,6 +75,8 @@ export interface CartItem {
     summaryTotal?: number | string;
     /** 商品原价总价，排除原始价格为0的场景 */
     origin_total?: number | string;
+    /** 基于 origin_total 乘以 商品数量的价格 */
+    summaryOriginTotal?: number | string;
     /** 商品数量 */
     num?: number;
     /** 商品图片 */

package/lib/modules/Cart/utils/cartProduct.js

@@ -46,6 +46,18 @@ var import_decimal = __toESM(require("decimal.js"));
 var import_utils = require("../../Product/utils");
 var import_utils2 = require("../../../solution/ShopDiscount/utils");
 var import_utils3 = require("../../Summary/utils");
+var toDiscountPayload = (discountItem) => {
+  var _a, _b;
+  return {
+    amount: discountItem.amount,
+    tag: discountItem.type,
+    par_value: (_a = discountItem.discount) == null ? void 0 : _a.percent,
+    config: discountItem.config,
+    metadata: {
+      discount_card_type: (_b = discountItem == null ? void 0 : discountItem.discount) == null ? void 0 : _b.discount_card_type
+    }
+  };
+};
 var handleVariantProduct = (product) => {
   var _a;
   if (product == null ? void 0 : product.product_variant_id) {
@@ -90,6 +102,14 @@ var formatProductToCartItem = (params) => {
       num,
       discounts
     });
+    const origin_total = getProductTotalPrice({
+      product: cartItem._productInit || cartItem._productOrigin,
+      bundle,
+      options,
+      num,
+      discounts: []
+    });
+    cartItem.summaryOriginTotal = (origin_total || 0) * (num || 1);
     cartItem.image = product == null ? void 0 : product.cover;
     cartItem.like_status = "common";
     cartItem.duration = product == null ? void 0 : product.duration;
@@ -184,17 +204,24 @@ var formatProductToCartItemOrigin = (params) => {
 var getProductTotalPrice = (params) => {
   const { product, bundle, options, discounts } = params;
   let price = Number(product.price);
+  const optionRows = (options == null ? void 0 : options.map((currentValue) => ({
+    unit: Number(currentValue.price ?? currentValue.add_price ?? 0),
+    num: Number(currentValue.num ?? currentValue.quantity ?? 1)
+  }))) ?? [];
   if (discounts == null ? void 0 : discounts.length) {
     discounts.forEach((currentValue) => {
       var _a;
-      price = (0, import_utils2.getDiscountAmount)({
-        amount: currentValue.amount,
-        tag: currentValue.type,
-        par_value: currentValue.discount.percent,
-        metadata: {
-          discount_card_type: (_a = currentValue == null ? void 0 : currentValue.discount) == null ? void 0 : _a.discount_card_type
+      const payload = toDiscountPayload(currentValue);
+      price = (0, import_utils2.getDiscountAmount)(payload, price, price);
+      if (((_a = currentValue == null ? void 0 : currentValue.config) == null ? void 0 : _a.deductOptionPrice) && optionRows.length) {
+        for (let i = 0; i < optionRows.length; i++) {
+          const row = optionRows[i];
+          optionRows[i] = {
+            ...row,
+            unit: (0, import_utils2.getDiscountAmount)(payload, row.unit, row.unit)
+          };
         }
-      }, price, price);
+      }
     });
   }
   if (bundle == null ? void 0 : bundle.length) {
@@ -202,10 +229,11 @@ var getProductTotalPrice = (params) => {
       return accumulator + Number(currentValue.price) * Number(currentValue.num);
     }, price);
   }
-  if (options == null ? void 0 : options.length) {
-    price = options.reduce((accumulator, currentValue) => {
-      return accumulator + Number(currentValue.price) * Number(currentValue.num);
-    }, price);
+  if (optionRows.length) {
+    price = optionRows.reduce(
+      (accumulator, row) => accumulator + row.unit * row.num,
+      price
+    );
   }
   return Math.max(0, price);
 };
@@ -313,7 +341,6 @@ var formatBundleToOrigin = (bundle) => {
       option: formatOptionsToOrigin(getBundleValueByKey("option")),
       discount_list: d.discount_list,
       "bundle_selling_price": d == null ? void 0 : d.price,
-      // "custom_price": d?.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference

package/lib/modules/Discount/types.d.ts

@@ -19,7 +19,7 @@ interface PackageSubItemUsageRules {
     type: 'universal_discount' | 'package_exclusive' | 'single_item_promo' | 'custom_usage_rules';
     rules: ("original_price" | "markup_price")[];
     package_scope?: {
-        type: 'all_packages' | 'specific_packages' | 'product_all' | 'products';
+        type: 'all_packages' | 'specific_packages';
         exclude_bundle_product_ids: number[];
         include_bundle_product_ids: number[];
         filter: 0 | 1;
@@ -33,6 +33,8 @@ interface Limitedrelationproductdata {
     product_ids: number[];
     product_collection_id: number[];
     package_sub_item_usage_rules?: PackageSubItemUsageRules;
+    filter: 0 | 1;
+    exclude_product_ids: number[];
 }
 interface ApplicableProductDetails {
     amount: string;
@@ -89,6 +91,7 @@ export interface Discount {
     balance: string;
     format_title: Formattitle;
     metadata?: {
+        num?: number;
         discount_card_type?: 'fixed_amount' | 'percent';
         custom_product_bundle_map_id?: string;
         validity_type?: "custom_schedule_validity" | "fixed_validity";
@@ -113,6 +116,21 @@ export interface Discount {
     isSelected?: boolean;
     isAvailable?: boolean;
     isUsed?: boolean;
+    config?: {
+        isAvailable?: boolean;
+        /** 最大抵扣金额 */
+        maxDeductionAmount?: number;
+        /** 每单最多使用张数 */
+        maxUsagePerOrder?: number;
+        /** 是否抵扣税费与附加费 */
+        deductTaxAndFee?: boolean;
+        /** 适用粒度（多商品共用） */
+        allowCrossProduct?: boolean;
+        /** 可用商品数量上限 */
+        applicableProductLimit?: number;
+        /** 是否抵扣单规格价格 (Option Price) */
+        deductOptionPrice?: boolean;
+    };
     applicableProductIds?: number[];
     applicableProductDetails: ApplicableProductDetails[];
     appliedProductDetails: ApplicableProductDetails[];

package/lib/modules/Order/index.d.ts

@@ -1,26 +1,13 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { OrderModuleAPI, CommitOrderParams, SubmitScanOrderParams, ScanOrderMoreParams, CheckoutOrderParams, UpdateProductInOrderParams } from './types';
+import { OrderModuleAPI, CommitOrderParams, CheckoutOrderParams } from './types';
 import { CartItem } from '../Cart/types';
-import { type SubmitPayloadEnhancer } from './utils';
-import type { ScanOrderOrderProduct, ScanOrderOrderProductIdentity, ScanOrderSummary, ScanOrderTempOrder } from '../../solution/ScanOrder/types';
-import type { Discount } from '../Discount/types';
-import { UnavailableReason } from '../Rules/types';
 export declare class OrderModule extends BaseModule implements Module, OrderModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
     private store;
     private request;
     private logger;
-    private window;
-    private cacheId;
-    private salesSummaryModuleName;
-    private rulesHooksOverride?;
-    /**
-     * Populate `savedAmount` on each discount based on product-level discount details.
-     * Only selected discounts get a non-zero value.
-     */
-    static populateSavedAmounts(productList: Array<Record<string, any>>, discountList: Array<Record<string, any>>): void;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     /**
@@ -35,52 +22,6 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
      * 记录错误日志
      */
     private logError;
-    private registerDiscountModules;
-    private createDefaultRulesHooks;
-    loadDiscountConfig(params: {
-        customerId: number;
-        action?: 'create';
-    }): Promise<void>;
-    getDiscountList(): Discount[];
-    scanCode(code: string, customerId?: number): Promise<{
-        isAvailable: boolean;
-        discountList: Discount[];
-        type: 'server' | 'clientCalc';
-        unavailableReason?: UnavailableReason;
-    }>;
-    applyDiscount(): void;
-    initTempOrder(params: {
-        cacheId?: string;
-        salesSummaryModuleName?: string;
-    }): void;
-    private getTempOrderStorageKey;
-    private restoreTempOrderFromStorage;
-    persistTempOrder(): void;
-    private createDefaultTempOrderInstance;
-    ensureTempOrder(): ScanOrderTempOrder;
-    restoreOrder(): ScanOrderTempOrder;
-    getTempOrder(): ScanOrderTempOrder | null;
-    addNewOrder(): Promise<ScanOrderTempOrder>;
-    getOrderProducts(): ScanOrderOrderProduct[];
-    private getSalesSummary;
-    recalculateSummary(options?: {
-        createIfMissing?: boolean;
-    }): Promise<ScanOrderSummary | null>;
-    getScanOrderSummary(): Promise<ScanOrderSummary>;
-    updateTempOrderNote(note: string): string;
-    updateTempOrderBuzzer(buzzer: string): string;
-    updateTempOrderContactsInfo(contactsInfo: any[]): any[];
-    addProductToOrder(product: Partial<ScanOrderOrderProduct> & ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
-    updateProductInOrder(params: UpdateProductInOrderParams): Promise<ScanOrderOrderProduct[]>;
-    removeProductFromOrder(identity: ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
-    submitTempOrder<T = any>(params?: {
-        cacheId?: string;
-        platform?: string;
-        businessCode?: string;
-        channel?: string;
-        type?: string;
-        enhancePayload?: SubmitPayloadEnhancer;
-    }): Promise<T>;
     createOrder(params: CommitOrderParams['query']): {
         type: "virtual" | "appointment_booking";
         platform: string;
@@ -110,9 +51,4 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
      * @returns 后端返回的订单数据（包含订单ID等）
      */
     createOrderByCheckout(params: CheckoutOrderParams): Promise<any>;
-    submitScanOrder<T = any>(params: SubmitScanOrderParams): Promise<T>;
-    scanOrderMore<T = any>(params: ScanOrderMoreParams): Promise<T>;
-    getOrderInfoByRemote(order_id: number): Promise<any>;
-    getLastOrderInfo(): Record<string, any> | undefined;
 }
-export type { UpdateProductInOrderParams } from './types';