@pisell/pisellos 2.2.302 → 2.2.304

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -9,10 +9,9 @@ exports.recommendOptimalPayments = recommendOptimalPayments;
  * 现金支付推荐算法
  * 
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 
 /**
@@ -48,364 +47,20 @@ const CURRENCY_DENOMINATIONS = exports.CURRENCY_DENOMINATIONS = {
   'DEFAULT': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
 };
 
-/**
- * 支付组合类型定义
- */
-
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  * 
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组
  * @returns 推荐支付金额数组
  */
 function recommendOptimalPayments(targetAmount, denominations) {
-  // 参数验证
-  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+  if (targetAmount <= 0 || !Number.isFinite(targetAmount)) {
     return [];
   }
-  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
-    return [Math.ceil(targetAmount)];
-  }
-
-  // 过滤有效面额并限制搜索空间以提高性能
-  const maxReasonableDenom = targetAmount * 5; // 适度限制搜索空间
-  const validDenoms = denominations.filter(denom => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8); // 限制面额数量以提高性能
-
-  if (validDenoms.length === 0) {
-    // 如果没有合适的面额，返回最接近的整数金额
-    return [Math.ceil(targetAmount)];
-  }
-  try {
-    // 处理精度问题，将金额转换为整数计算
-    const precision = 100; // 假设最小单位是0.01
-    const target = Math.round(targetAmount * precision);
-    const denoms = validDenoms.map(d => Math.round(d * precision)).sort((a, b) => b - a);
-
-    // 存储不同的支付组合方案
-    const paymentOptions = [];
-
-    // 首先尝试找到精确匹配的组合
-    const exactCombination = findExactCombination(target, denoms, precision);
-    if (exactCombination) {
-      paymentOptions.push(exactCombination);
-    }
-
-    // 为了提高效率，我们将按币种数量来生成组合
-    // 1币种组合：只用一种面额
-    for (let i = 0; i < Math.min(denoms.length, 6); i++) {
-      const denom = denoms[i];
-      const count = Math.ceil(target / denom);
-      const sum = count * denom;
-      if (sum >= target && count <= 12) {
-        // 限制硬币数量以提高性能
-        paymentOptions.push({
-          combination: Array(count).fill(denom / precision),
-          sum: sum / precision,
-          coinCount: count,
-          denomTypes: 1
-        });
-      }
-    }
-
-    // 2币种组合：使用两种面额（大幅限制搜索范围以提高性能）
-    for (let i = 0; i < Math.min(denoms.length - 1, 5); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length, 6); j++) {
-        const denom1 = denoms[i];
-        const denom2 = denoms[j];
-
-        // 大幅限制搜索范围，基于目标金额动态调整
-        const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
-        const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
-        for (let count1 = 1; count1 <= maxCount1; count1++) {
-          for (let count2 = 1; count2 <= maxCount2; count2++) {
-            const sum = count1 * denom1 + count2 * denom2;
-            if (sum >= target) {
-              const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision)];
-              paymentOptions.push({
-                combination: combination,
-                sum: sum / precision,
-                coinCount: count1 + count2,
-                denomTypes: 2
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // 3币种组合：使用三种面额（大幅限制搜索以提高效率）
-    for (let i = 0; i < Math.min(denoms.length - 2, 3); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length - 1, 4); j++) {
-        for (let k = j + 1; k < Math.min(denoms.length, 5); k++) {
-          const denom1 = denoms[i];
-          const denom2 = denoms[j];
-          const denom3 = denoms[k];
-
-          // 大幅限制搜索范围
-          const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 5);
-          const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 6);
-          const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
-          for (let count1 = 1; count1 <= maxCount1; count1++) {
-            for (let count2 = 1; count2 <= maxCount2; count2++) {
-              for (let count3 = 1; count3 <= maxCount3; count3++) {
-                const sum = count1 * denom1 + count2 * denom2 + count3 * denom3;
-                if (sum >= target) {
-                  const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision)];
-                  paymentOptions.push({
-                    combination: combination,
-                    sum: sum / precision,
-                    coinCount: count1 + count2 + count3,
-                    denomTypes: 3
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 4币种组合：使用四种面额（极度限制搜索以提高性能）
-    for (let i = 0; i < Math.min(denoms.length - 3, 2); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length - 2, 3); j++) {
-        for (let k = j + 1; k < Math.min(denoms.length - 1, 4); k++) {
-          for (let l = k + 1; l < Math.min(denoms.length, 5); l++) {
-            const denom1 = denoms[i];
-            const denom2 = denoms[j];
-            const denom3 = denoms[k];
-            const denom4 = denoms[l];
-
-            // 极度限制搜索范围
-            const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 3);
-            const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 4);
-            const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 5);
-            const maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
-            for (let count1 = 1; count1 <= maxCount1; count1++) {
-              for (let count2 = 1; count2 <= maxCount2; count2++) {
-                for (let count3 = 1; count3 <= maxCount3; count3++) {
-                  for (let count4 = 1; count4 <= maxCount4; count4++) {
-                    const sum = count1 * denom1 + count2 * denom2 + count3 * denom3 + count4 * denom4;
-                    if (sum >= target) {
-                      const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision), ...Array(count4).fill(denom4 / precision)];
-                      paymentOptions.push({
-                        combination: combination,
-                        sum: sum / precision,
-                        coinCount: count1 + count2 + count3 + count4,
-                        denomTypes: 4
-                      });
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 如果没有找到任何组合，提供默认建议
-    if (paymentOptions.length === 0) {
-      // 找到大于等于目标金额的最小面额
-      const minValidDenom = validDenoms.find(denom => denom >= targetAmount);
-      if (minValidDenom) {
-        return [minValidDenom];
-      } else {
-        // 使用最大面额的组合
-        const maxDenom = Math.max(...validDenoms);
-        const count = Math.ceil(targetAmount / maxDenom);
-        return [count * maxDenom];
-      }
-    }
-
-    // 移除重复和扩展组合
-    const uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
-
-    // 按币种类型数量排序，然后按总硬币数量排序，最后按金额排序
-    uniqueCombinations.sort((a, b) => {
-      if (a.denomTypes !== b.denomTypes) {
-        return a.denomTypes - b.denomTypes;
-      }
-      if (a.coinCount !== b.coinCount) {
-        return a.coinCount - b.coinCount;
-      }
-      return a.sum - b.sum;
-    });
-
-    // 按金额去重并返回推荐的支付金额
-    const uniqueAmounts = new Set();
-    const finalResults = [];
-    for (const item of uniqueCombinations) {
-      const roundedAmount = Math.round(item.sum * 100) / 100; // 处理浮点数精度
-      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
-        uniqueAmounts.add(roundedAmount);
-        finalResults.push(roundedAmount);
-      }
-    }
-    return finalResults.sort((a, b) => a - b);
-  } catch (error) {
-    // 发生错误时返回安全的默认值
-    console.warn('推荐支付金额计算出错:', error);
-    // 返回最接近的整数金额作为兜底
-    const safeAmount = Math.ceil(targetAmount);
-    return [targetAmount, safeAmount];
-  }
-}
-
-/**
- * 尝试找到精确匹配目标金额的组合
- */
-function findExactCombination(target, denoms, precision) {
-  // 简单的深度优先搜索，限制搜索深度
-  function dfs(remaining, denomIndex, currentCombination) {
-    if (remaining === 0) {
-      return currentCombination;
-    }
-    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
-      return null;
-    }
-    const denom = denoms[denomIndex];
-
-    // 尝试使用当前面额 0 到 maxCount 次
-    const maxCount = Math.min(Math.floor(remaining / denom), 8);
-    for (let count = maxCount; count >= 0; count--) {
-      const newCombination = [...currentCombination, ...Array(count).fill(denom)];
-      const result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
-      if (result) {
-        return result;
-      }
-    }
-    return null;
-  }
-  const exactMatch = dfs(target, 0, []);
-  if (exactMatch && exactMatch.length > 0) {
-    const denomTypes = new Set(exactMatch).size;
-    return {
-      combination: exactMatch.map(d => d / precision),
-      sum: target / precision,
-      coinCount: exactMatch.length,
-      denomTypes: denomTypes
-    };
-  }
-  return null;
-}
-
-/**
- * 移除重复和扩展组合
- * 核心原理：如果组合A包含组合B的所有硬币，并且还有额外硬币，则A是B的扩展，应该被移除
- */
-function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
-  const result = [];
-
-  // 按币种类型数量、硬币数量、金额排序，确保较简单的组合在前面
-  combinations.sort((a, b) => {
-    if (a.denomTypes !== b.denomTypes) {
-      return a.denomTypes - b.denomTypes;
-    }
-    if (a.coinCount !== b.coinCount) {
-      return a.coinCount - b.coinCount;
-    }
-    return a.sum - b.sum;
-  });
-  for (let i = 0; i < combinations.length; i++) {
-    const current = combinations[i];
-    let shouldSkip = false;
-
-    // 检查当前组合是否与已添加的组合重复或者是扩展
-    for (let j = 0; j < result.length; j++) {
-      const existing = result[j];
-
-      // 如果完全相同，跳过
-      if (isSameCombination(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-
-      // 如果当前组合是已存在组合的扩展，跳过
-      if (isExtensionOf(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-    }
-
-    // 检查是否有其他组合是当前组合的扩展，如果有，移除那些扩展
-    if (!shouldSkip) {
-      // 移除所有当前组合的扩展
-      for (let j = result.length - 1; j >= 0; j--) {
-        if (isExtensionOf(result[j].combination, current.combination)) {
-          result.splice(j, 1);
-        }
-      }
-      result.push(current);
-    }
-  }
-  return result;
-}
-
-/**
- * 检查组合A是否是组合B的扩展（即A包含B的所有硬币，并且还有额外的硬币）
- */
-function isExtensionOf(combinationA, combinationB) {
-  // 如果A的硬币数量少于等于B，A不可能是B的扩展
-  if (combinationA.length <= combinationB.length) {
-    return false;
-  }
-
-  // 统计每个面额的数量
-  const countA = {};
-  const countB = {};
-  combinationA.forEach(coin => {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(coin => {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查B的所有面额在A中是否都有足够的数量
-  for (const coin in countB) {
-    if (!countA[coin] || countA[coin] < countB[coin]) {
-      return false;
-    }
-  }
-
-  // 检查A是否有B没有的额外硬币
-  let hasExtra = false;
-  for (const coin in countA) {
-    if (countA[coin] > (countB[coin] || 0)) {
-      hasExtra = true;
-      break;
-    }
-  }
-  return hasExtra;
-}
-
-/**
- * 检查两个组合是否本质相同（相同的面额组合）
- */
-function isSameCombination(combinationA, combinationB) {
-  if (combinationA.length !== combinationB.length) {
-    return false;
-  }
-  const countA = {};
-  const countB = {};
-  combinationA.forEach(coin => {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(coin => {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查两个组合是否有相同的面额和数量
-  for (const coin in countA) {
-    if (countA[coin] !== (countB[coin] || 0)) {
-      return false;
-    }
-  }
-  for (const coin in countB) {
-    if (countB[coin] !== (countA[coin] || 0)) {
-      return false;
-    }
-  }
-  return true;
+  const precision = 100;
+  const normalizedTarget = Math.round(targetAmount * precision) / precision;
+  const higherDenominations = [...new Set((Array.isArray(denominations) ? denominations : []).filter(denomination => denomination > 0 && Number.isFinite(denomination)).map(denomination => Math.round(denomination * precision) / precision))].filter(denomination => denomination > normalizedTarget).sort((a, b) => a - b).slice(0, 3);
+  return [normalizedTarget, ...higherDenominations];
 }

package/lib/modules/Payment/walletpass.js

@@ -650,17 +650,20 @@ class WalletPassPaymentImpl {
         this.paymentModule.logInfo('[WalletPass] 商品列表为空，跳过获取用户识别码列表');
         return [];
       }
-      const platform = this.paymentModule.getPlatform();
-      if (platform === 'pc' || platform === 'h5') {
-        this.userIdentificationCodes = [];
-        this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
-          userIdentificationCodes: []
-        });
-        this.paymentModule.logInfo('[WalletPass] 用户端平台跳过获取用户识别码列表', {
-          platform
-        });
-        return [];
-      }
+
+      // const platform = this.paymentModule.getPlatform();
+      // if (platform === 'pc' || platform === 'h5') {
+      //   this.userIdentificationCodes = [];
+      //   this.emitEvent(WalletPassHooks.OnUserIdentificationCodesUpdated, {
+      //     userIdentificationCodes: [],
+      //   } as OnUserIdentificationCodesUpdatedEventData);
+      //   this.paymentModule.logInfo(
+      //     '[WalletPass] 用户端平台跳过获取用户识别码列表',
+      //     { platform },
+      //   );
+      //   return [];
+      // }
+
       if (typeof newParams.payment_order_id === 'string' && newParams.payment_order_id.startsWith('LOCAL_')) {
         newParams.payment_order_id = undefined;
       }

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

@@ -23,12 +23,25 @@ export interface ProductDataVariant {
     module_data_id: number;
     /** 关联 data_variant_rule.id */
     data_variant_rule_id: number;
+    /** 多货币结算等业务类型 */
+    business_type?: 'multi_currency_settlement' | string;
+    /** 数据状态；多货币结算仅处理 enable 记录 */
+    status?: 'enable' | 'disable' | string;
     /** 命中策略后覆盖到商品上的字段 */
     data: Record<string, any>;
     created_at: string | null;
     updated_at: string | null;
     deleted_at: string | null;
 }
+export interface ProductSettlementOption extends Record<string, any> {
+    settlement_type: 'legal_currency' | 'virtual_currency' | string;
+    currency_product_id?: number;
+    price: string;
+    data_variant_id?: number;
+    data_variant_rule_id: number | string;
+    available: boolean;
+    disabled_reason?: string;
+}
 /**
  * 商品基本信息接口
  */
@@ -61,6 +74,8 @@ export interface ProductData {
     sum_stock: number;
     /** 商品价格 */
     price: string;
+    /** 当前上下文解析出的可选结算货币 */
+    available_settlement_options?: ProductSettlementOption[];
     /** 商品原价 */
     original_price: string;
     /** 商品成本价 */
@@ -239,6 +254,14 @@ export interface ProductData {
     option_group_count: number;
     /** 智能定价变体列表，/product/query with dataVariants 返回 */
     data_variants?: ProductDataVariant[];
+    /**
+     * 商品接口规则计算结果；data_variant_ids 按优先级从高到低排列。
+     * 空数组表示规则已经计算完成但没有命中 Data Variant。
+     */
+    metadata?: {
+        data_variant_ids?: Array<number | string>;
+        [key: string]: any;
+    };
     /** 服务时长 */
     service_times?: any;
 }

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

@@ -1,6 +1,6 @@
 import { Module, PisellCore } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { ProductListLoadProductsParams } from './types';
+import { ProductListLoadProductsParams, ProductListStoreQueryParams } from './types';
 import { ProductData } from '../Product/types';
 export * from './types';
 export declare class ProductList extends BaseModule implements Module {
@@ -52,6 +52,7 @@ export declare class ProductList extends BaseModule implements Module {
     getRawProductPriceSources(ids: number[]): Map<number, ProductData>;
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<ProductData | undefined>;
+    queryProducts(params?: ProductListStoreQueryParams): Promise<ProductData[]>;
     getProductByIds(ids: number[]): Promise<ProductData[] | undefined>;
     addProduct(products: ProductData[]): Promise<void>;
     selectProducts(products: ProductData[]): Promise<void>;

package/lib/modules/ProductList/index.js

@@ -25,6 +25,15 @@ Object.keys(_types).forEach(function (key) {
   });
 });
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function normalizeQuerySet(values) {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  const normalized = values.map(value => String(value ?? '').trim()).filter(Boolean);
+  return normalized.length ? new Set(normalized) : null;
+}
+function matchesAny(values, querySet) {
+  if (!querySet) return true;
+  return values.some(value => querySet.has(String(value ?? '').trim()));
+}
 class ProductList extends _BaseModule.BaseModule {
   defaultName = 'productList';
   defaultVersion = '1.0.0';
@@ -281,10 +290,46 @@ class ProductList extends _BaseModule.BaseModule {
     const product = this.store.list.find(product => product.id === id);
     return product ? (0, _lodashEs.cloneDeep)(product) : undefined;
   }
+  async queryProducts(params = {}) {
+    const includeIds = normalizeQuerySet(params.includeIds);
+    const excludeIds = normalizeQuerySet(params.excludeIds);
+    const categoryIds = normalizeQuerySet(params.categoryIds);
+    const collectionIds = normalizeQuerySet(params.collectionIds);
+    const extensionTypes = normalizeQuerySet(params.extensionTypes);
+    const statuses = normalizeQuerySet(params.statuses);
+    const channelApplications = normalizeQuerySet(params.channelApplications);
+    const codeOrBarcode = typeof params.codeOrBarcode === 'string' ? params.codeOrBarcode.trim() : '';
+    const products = (this.store.list || []).filter(product => {
+      const productId = String(product.id ?? '').trim();
+      if (includeIds && !includeIds.has(productId)) return false;
+      if (excludeIds && excludeIds.has(productId)) return false;
+      if (categoryIds) {
+        const productCategoryIds = (product.categories || []).flatMap(category => [category?.id, category?.pivot?.product_category_id]);
+        if (!matchesAny(productCategoryIds, categoryIds)) return false;
+      }
+      if (collectionIds) {
+        const productCollectionIds = (product.collection || []).map(collection => collection?.id);
+        if (!matchesAny(productCollectionIds, collectionIds)) return false;
+      }
+      if (extensionTypes && !extensionTypes.has(String(product.extension_type ?? '').trim())) return false;
+      if (statuses && !statuses.has(String(product.status ?? '').trim())) return false;
+      if (channelApplications) {
+        if (!matchesAny(product.channel_application || [], channelApplications)) return false;
+      }
+      if (codeOrBarcode) {
+        const code = typeof product.code === 'string' ? product.code.trim() : '';
+        const barcode = typeof product.barcode === 'string' ? product.barcode.trim() : '';
+        if (code !== codeOrBarcode && barcode !== codeOrBarcode) return false;
+      }
+      return true;
+    });
+    return (0, _lodashEs.cloneDeep)(products);
+  }
   async getProductByIds(ids) {
     await this.core.effects.emit(`${this.name}:onGetProductByIds`, this.store.list);
-    const products = this.store.list.filter(product => ids.includes(product.id));
-    return products;
+    return this.queryProducts({
+      includeIds: ids
+    });
   }
   async addProduct(products) {
     // list 需要根据 id 去重

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

@@ -15,6 +15,16 @@ export interface ProductListLoadProductsParams {
     /** 智能定价条件上下文，仅影响策略命中，不参与商品集合筛选 */
     strategy_context?: Record<string, any>;
 }
+export interface ProductListStoreQueryParams {
+    includeIds?: Array<number | string>;
+    excludeIds?: Array<number | string>;
+    categoryIds?: Array<number | string>;
+    collectionIds?: Array<number | string>;
+    extensionTypes?: string[];
+    statuses?: ProductData['status'][];
+    channelApplications?: string[];
+    codeOrBarcode?: string;
+}
 export interface ProductListData {
     list: ProductData[];
     selectProducts: ProductData[];

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

@@ -14,6 +14,11 @@ export declare class RulesModule extends BaseModule implements Module, RulesModu
     setRulesList(rulesList: Rules[]): Promise<void>;
     getRulesList(): Rules[];
     getWalletPassEvaluator(): import("../..").WalletPassEvaluator | undefined;
+    private normalizeHolderRecordIds;
+    /**
+     * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+     * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+     */
     private checkHolderMatch;
     isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, orderTotalAmount, holders, isFormSubject, }: {
         oldDiscountList: Discount[];

package/lib/modules/Rules/index.js

@@ -38,21 +38,30 @@ class RulesModule extends _BaseModule.BaseModule {
   getWalletPassEvaluator() {
     return this.window.getWalletPassEvaluator?.();
   }
+  normalizeHolderRecordIds(value) {
+    const records = Array.isArray(value) ? value : [value];
+    return Array.from(new Set(records.map(record => {
+      if (record && typeof record === 'object') {
+        return record.form_record_id;
+      }
+      return record;
+    }).filter(record => record !== undefined && record !== null && record !== '' && record !== 0 && record !== '0').map(String)));
+  }
 
-  // 商品不需要holder,则不需要判断，直接返回true，商品需要holder但是还没填写，那么暂时不使用带有holder的券，直到填写才去匹配
+  /**
+   * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+   * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+   */
   checkHolderMatch(discount, product, holders) {
     // 非表单类型 holder 视为匹配
     if (discount.holder?.holder_type !== 'form') return true;
-    // 主预约holder, 目前（20251124）默认只考虑单个holder的情况
-    // 旧版 holders[0].form_record_id 新版 holders[0]
-    const orderHolderId = Array.isArray(holders) && holders.length > 0 ? holders[0].form_record_id || holders[0] : undefined;
-    const productHolderId = Array.isArray(product.holder_id) ? product.holder_id[0] : product.holder_id;
-    // 商品不需要选holder，则不对比holder，直接返回true，
-    if (!product.isNeedHolder) return true;
-    // 商品需要holder，但父预约及商品都无holder，返回false
-    if (!orderHolderId && !productHolderId) return false;
-    // 最终直接匹配 holder 是否相同
-    return (productHolderId || orderHolderId) === discount.holder.holder_id;
+    const discountHolderIds = this.normalizeHolderRecordIds(discount.holder.holder_id);
+    if (!discountHolderIds.length) return false;
+    const productHolderIds = this.normalizeHolderRecordIds(product.holder_id);
+    const candidateHolderIds = productHolderIds.length ? productHolderIds : this.normalizeHolderRecordIds(holders);
+    if (!candidateHolderIds.length) return false;
+    const discountHolderIdSet = new Set(discountHolderIds);
+    return candidateHolderIds.some(holderId => discountHolderIdSet.has(holderId));
   }
 
   // 判断discountList 是否可以对当前productList生效
@@ -1119,7 +1128,8 @@ class RulesModule extends _BaseModule.BaseModule {
           processedFlatItemsMap.set(flatItem._id, [{
             ...flatItem,
             discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(flatItem.bundleItem?.discount_list || []) : this.filterDiscountListByType(flatItem.bundleItem?.discount_list || [], 'promotion'),
-            price: isManualDiscount ? flatItem.bundleItem.price : flatItem.bundleItem.original_price,
+            price: flatItem.bundleItem.price,
+            bundle_selling_price: flatItem.bundleItem.bundle_selling_price ?? (isManualDiscount ? flatItem.bundleItem.price : flatItem.bundleItem.original_price),
             processed: true
           }]);
         }

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

@@ -30,6 +30,7 @@ export declare class SalesSummaryModule extends BaseModule implements Module, Sa
         taxRate?: number;
         shopDiscount?: string | number;
         channel?: string;
+        virtualSettlementMode?: boolean;
     }): Promise<{
         tax_title: string;
         tax_rate: number | undefined;

package/lib/modules/SalesSummary/index.js

@@ -126,7 +126,8 @@ class SalesSummaryModule extends _BaseModule.BaseModule {
       isPriceIncludeTax,
       taxRate,
       shopDiscount,
-      channel
+      channel,
+      virtualSettlementMode = false
     } = params;
     const summaryChannel = channel || this.resolveChannel();
     if (summaryChannel !== this.surchargeListChannel) {
@@ -151,7 +152,8 @@ class SalesSummaryModule extends _BaseModule.BaseModule {
       surchargeList: this.store.surchargeList,
       scheduleById,
       isInScheduleByDate: _Schedule.ScheduleModule.isInScheduleByDate,
-      shopDiscount
+      shopDiscount,
+      virtualSettlementMode
     });
     const summaryWithTaxMeta = {
       ...summary,

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

@@ -64,5 +64,6 @@ export interface SalesSummaryModuleAPI {
         taxRate?: number;
         shopDiscount?: string | number;
         channel?: string;
+        virtualSettlementMode?: boolean;
     }): Promise<SalesSummaryData>;
 }

package/lib/modules/SalesSummary/utils.d.ts

@@ -8,4 +8,5 @@ export declare function calculateSalesSummary(params: {
     scheduleById?: Record<string, any>;
     isInScheduleByDate?: any;
     shopDiscount?: string | number;
+    virtualSettlementMode?: boolean;
 }): SalesSummaryData;