@pisell/pisellos 0.10.41 → 0.10.43

package/lib/modules/Rules/index.js

@@ -11,6 +11,7 @@ var _utils2 = require("../Cart/utils");
 var _decimal = _interopRequireDefault(require("decimal.js"));
 var _lodashEs = require("lodash-es");
 var _dayjs = _interopRequireDefault(require("dayjs"));
+var _entitlementPass = require("../Discount/entitlementPass");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class RulesModule extends _BaseModule.BaseModule {
   defaultName = 'rules';
@@ -97,7 +98,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
     // 合并新旧折扣列表，并计算折扣结果,注意，如果旧折扣里有 isEditMode 为 true 的优惠券，则不合并
     // 保留之前扫码得到的商品券（isScan: true）
-    const filteredOldDiscountList = oldDiscountList.filter(discount => !discount.isEditMode && (discount.tag !== 'good_pass' || discount.isScan));
+    const filteredOldDiscountList = oldDiscountList.filter(discount => !discount.isEditMode && (!(0, _entitlementPass.isFullCoveragePass)(discount) || discount.isScan));
     const mergedDiscountList = (0, _utils.uniqueById)([...filteredOldDiscountList, ...newDiscountList]);
     const result = this.calcDiscount({
       discountList: mergedDiscountList,
@@ -221,8 +222,8 @@ class RulesModule extends _BaseModule.BaseModule {
       if (!selectedDiscount) return false;
       const uid = getOriginProductUid(originProduct);
       if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
-      const discountType = selectedDiscount.tag || selectedDiscount.type;
-      return selectedDiscount.isEditMode === true && selectedDiscount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+      const discountType = selectedDiscount.tag || selectedDiscount.type || '';
+      return selectedDiscount.isEditMode === true && selectedDiscount.isSelected === true && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
     };
     const resolveReapplyBookingDiscountPercent = (originProduct, selectedDiscount) => {
       if (!shouldReapplyBookingDiscount(originProduct, selectedDiscount)) return undefined;
@@ -267,8 +268,8 @@ class RulesModule extends _BaseModule.BaseModule {
       };
     }
     const canUseEditModeDiscountForReapply = discount => {
-      const discountType = discount.tag || discount.type;
-      return reapplyBookingDiscountProductUids.size > 0 && discount.isEditMode === true && discount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+      const discountType = discount.tag || discount.type || '';
+      return reapplyBookingDiscountProductUids.size > 0 && discount.isEditMode === true && discount.isSelected === true && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
     };
 
     // 过滤掉手动取消false的优惠券，但仅用于应用优惠逻辑。
@@ -342,6 +343,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
       // 辅助函数：判断是否是商品券
       const isGoodPass = discount => discount.tag === 'good_pass';
+      const isEntitlement = discount => (0, _entitlementPass.isEntitlementPass)(discount);
 
       // 辅助函数：判断是否是订单级折扣卡
       const isOrderLevelDiscount = discount => discount.tag === 'product_discount_card' && discount.metadata?.discount_calculation_mode === 'order_level';
@@ -403,6 +405,14 @@ class RulesModule extends _BaseModule.BaseModule {
         }
         return 0;
       }
+      const entitlementA = isEntitlement(a);
+      const entitlementB = isEntitlement(b);
+      if (entitlementA || entitlementB) {
+        if (entitlementA && entitlementB) {
+          return (0, _entitlementPass.compareEntitlementPassPriority)(a, b);
+        }
+        return entitlementA ? -1 : 1;
+      }
 
       // 1. 先按优先级排序
       const priorityA = getPriority(a);
@@ -473,14 +483,22 @@ class RulesModule extends _BaseModule.BaseModule {
     const evaluator = this.getWalletPassEvaluator();
     if (evaluator) {
       addModeDiscount.forEach(discount => {
-        const discountType = discount.tag || discount.type;
-        // 只对 good_pass 和 discount_card 类型执行策略检查
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
+        const discountType = discount.tag || discount.type || '';
+        // 对两类全额抵扣卡和折扣卡执行附加策略检查。
+        if (['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
+          const entitlementQuota = (0, _entitlementPass.isEntitlementPass)(discount) ? (0, _entitlementPass.resolveEntitlementQuota)(discount) : null;
+          if ((0, _entitlementPass.isEntitlementPass)(discount) && !entitlementQuota) {
+            discount.config = {
+              isAvailable: false
+            };
+            return;
+          }
+
           // 转换 discount 为 Voucher 格式
           const voucher = {
             id: discount.id,
             amount: Number(discount.par_value || 0),
-            balance: Number(discount.balance || 0),
+            balance: entitlementQuota?.type === 'unlimited' ? Number.MAX_SAFE_INTEGER : entitlementQuota?.type === 'limited' ? entitlementQuota.balance : Number(discount.balance || 0),
             type: discountType,
             product_id: discount.product_id,
             unified_available_status: 1,
@@ -536,11 +554,118 @@ class RulesModule extends _BaseModule.BaseModule {
     });
      */
 
-    // 标记已使用的优惠券
+    // good_pass / 折扣卡保持原有的一次性使用标记。
     const usedDiscounts = new Map();
 
+    // Entitlement Pass 单独记录本次重算新增分配的次数。
+    const entitlementUsageCounts = new Map();
+
     // 🔥 统计每个 product_id（商品券商品id）已使用的数量，用于 maxUsagePerOrder 限制
     const usedProductIdCounts = new Map();
+    const markDiscountUsed = (discount, count = 1) => {
+      if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+        entitlementUsageCounts.set(discount.id, (entitlementUsageCounts.get(discount.id) || 0) + count);
+        return;
+      }
+      usedDiscounts.set(discount.id, true);
+    };
+    const isDiscountUsed = discount => {
+      if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+        return (entitlementUsageCounts.get(discount.id) || 0) > 0;
+      }
+      return usedDiscounts.get(discount.id) === true;
+    };
+    const buildFullCoveragePassUsageGroups = (discounts, requestedCount) => {
+      const groups = [];
+      const pendingUsedDiscounts = new Set(Array.from(usedDiscounts.entries()).filter(([, used]) => used).map(([discountId]) => discountId));
+      const pendingEntitlementCounts = new Map(entitlementUsageCounts);
+      const pendingProductCounts = new Map(usedProductIdCounts);
+      const firstGoodPass = discounts.find(discount => (0, _entitlementPass.isFullCoveragePass)(discount) && !(0, _entitlementPass.isEntitlementPass)(discount));
+      const legacyGoodPassPerLineLimit = firstGoodPass ? Number(firstGoodPass.config?.maxUsagePerOrder || 0) : 0;
+      let allocatedGoodPassCount = 0;
+      let remaining = Math.max(Math.floor(requestedCount), 0);
+      for (const discount of discounts) {
+        if (remaining <= 0) break;
+        if (!(0, _entitlementPass.isFullCoveragePass)(discount)) continue;
+        const currentEntitlementCount = pendingEntitlementCounts.get(discount.id) || 0;
+        let availableCount = (0, _entitlementPass.isEntitlementPass)(discount) ? (0, _entitlementPass.getRemainingEntitlementUses)(discount, currentEntitlementCount, remaining) : pendingUsedDiscounts.has(discount.id) ? 0 : 1;
+        if (!(0, _entitlementPass.isEntitlementPass)(discount) && legacyGoodPassPerLineLimit > 0) {
+          availableCount = Math.min(availableCount, Math.max(Math.floor(legacyGoodPassPerLineLimit) - allocatedGoodPassCount, 0));
+        }
+        const maxUsagePerOrder = Number(discount.config?.maxUsagePerOrder || 0);
+        if ((0, _entitlementPass.isEntitlementPass)(discount) && maxUsagePerOrder > 0) {
+          const currentProductCount = pendingProductCounts.get(discount.product_id) || 0;
+          availableCount = Math.min(availableCount, Math.max(Math.floor(maxUsagePerOrder) - currentProductCount, 0));
+        }
+        const allocatedCount = Math.min(availableCount, remaining);
+        if (allocatedCount <= 0) continue;
+        const existingGroup = groups.find(group => String(group.discount.id) === String(discount.id));
+        if (existingGroup) {
+          existingGroup.count += allocatedCount;
+        } else {
+          groups.push({
+            discount,
+            count: allocatedCount
+          });
+        }
+        if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+          pendingEntitlementCounts.set(discount.id, currentEntitlementCount + allocatedCount);
+        } else {
+          pendingUsedDiscounts.add(discount.id);
+          allocatedGoodPassCount += allocatedCount;
+        }
+        pendingProductCounts.set(discount.product_id, (pendingProductCounts.get(discount.product_id) || 0) + allocatedCount);
+        remaining -= allocatedCount;
+      }
+      return groups;
+    };
+    const mergeEntitlementAppliedProductDetails = details => {
+      const mergedDetails = [];
+      const mergedIndexByKey = new Map();
+      const toComparableNumber = value => {
+        const numberValue = Number(value);
+        return Number.isFinite(numberValue) ? String(numberValue) : String(value ?? '');
+      };
+      for (const detail of details || []) {
+        if (!(0, _entitlementPass.isEntitlementPass)(detail)) {
+          mergedDetails.push(detail);
+          continue;
+        }
+        const resourceId = detail?.discount?.resource_id ?? detail?.resource_id;
+        if (resourceId === undefined || resourceId === null) {
+          mergedDetails.push(detail);
+          continue;
+        }
+        const key = [resourceId, detail?.discount?.product_id ?? '', detail?.metadata?.custom_product_bundle_map_id ?? '', toComparableNumber(detail?.amount), toComparableNumber(detail?.discount?.fixed_amount)].join('|');
+        const rawUsageCount = Number(detail?.metadata?.num ?? detail?._num ?? 1);
+        const usageCount = Number.isFinite(rawUsageCount) && rawUsageCount > 0 ? rawUsageCount : 1;
+        const mergedIndex = mergedIndexByKey.get(key);
+        if (mergedIndex === undefined) {
+          mergedIndexByKey.set(key, mergedDetails.length);
+          mergedDetails.push({
+            ...detail,
+            metadata: {
+              ...(detail?.metadata || {}),
+              num: usageCount
+            },
+            _num: usageCount
+          });
+          continue;
+        }
+        const existed = mergedDetails[mergedIndex];
+        const existedUsageCount = Number(existed?.metadata?.num ?? existed?._num ?? 1);
+        const totalUsageCount = existedUsageCount + usageCount;
+        mergedDetails[mergedIndex] = {
+          ...existed,
+          metadata: {
+            ...(existed?.metadata || {}),
+            num: totalUsageCount
+          },
+          _num: totalUsageCount
+        };
+      }
+      return mergedDetails;
+    };
 
     // 记录每个优惠券适用的商品ID
     const discountApplicability = new Map();
@@ -586,7 +711,7 @@ class RulesModule extends _BaseModule.BaseModule {
       }
 
       // 编辑的商品使用了优惠券不可用
-      const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(d => d.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(d.tag || d.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(d => d.id));
+      const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(d => d.id && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(d.tag || d.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(d => d.id));
       if (!isAvailableProduct) {
         return false;
       }
@@ -777,23 +902,23 @@ class RulesModule extends _BaseModule.BaseModule {
         const isLimitedProduct = (limitedData.type === 'product_all' && limitedData.filter !== 1 || limitedData.type === 'product_all' && limitedData.filter === 1 && !limitedData.exclude_product_ids.includes(product.id) || limitedData.product_ids && limitedData.product_ids.includes(product.id)) && isHolderMatch;
 
         // 编辑的商品 使用了优惠券不可用
-        const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(discount => discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(discount => discount.id));
+        const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(discount => discount.id && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(discount => discount.id));
 
         // 套餐是否可用判断
         const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
 
         // 判断优惠券是否适用于该商品
-        if (isAvailableProduct && !isItemRewardProductDiscount && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable) {
+        if (isAvailableProduct && !isItemRewardProductDiscount && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable && (!(0, _entitlementPass.isEntitlementPass)(discount) || (0, _entitlementPass.getRemainingEntitlementUses)(discount, 0, 1) > 0)) {
           // 记录此优惠券适用的商品
           discountApplicability.get(discount.id)?.push(product.id);
 
           // 记录可抵扣的商品详情
           const applicableProducts = discountApplicableProducts.get(discount.id) || [];
           const discountType = discount.tag || discount.type;
-          const isGoodPass = discountType === 'good_pass';
+          const isFullCoverage = (0, _entitlementPass.isFullCoveragePass)(discount);
 
           // 使用数量
-          const num = isGoodPass || flatItem?.type === 'main' ? 1 : product.num;
+          const num = isFullCoverage || flatItem?.type === 'main' ? 1 : product.num;
           const productData = {
             amount: product.price * num,
             type: discountType,
@@ -911,7 +1036,7 @@ class RulesModule extends _BaseModule.BaseModule {
       const hasExistingWalletDiscount = product.discount_list?.length && product?.discount_list?.every(discount => {
         const discountIdentity = discount.id ?? discount.discount?.resource_id;
         const discountType = discount.tag || discount.type;
-        return Boolean(discountIdentity && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
+        return Boolean(discountIdentity && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
       });
 
       // 已持久化且已有钱包券/折扣卡的商品行跳过，保留后端历史折扣结果。
@@ -928,8 +1053,8 @@ class RulesModule extends _BaseModule.BaseModule {
       // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
       const applicableDiscounts = sortedDiscountList.filter(discount => {
         if (this.isItemRewardProductDiscount(product)) return false;
-        // 🔥 检查策略可用性（针对 good_pass 和折扣卡）
-        const discountType = discount.tag || discount.type;
+        // 🔥 检查策略可用性（针对全额抵扣卡和折扣卡）
+        const discountType = discount.tag || discount.type || '';
         const currentOriginUid = getOriginProductUid(originProduct);
         const isReapplyEditModeDiscountForProduct = discount.isEditMode && reapplyBookingDiscountProductUids.size > 0 && currentOriginUid && reapplyBookingDiscountProductUids.has(String(currentOriginUid)) && discount.isSelected === true;
         if (discount.isEditMode && reapplyBookingDiscountProductUids.size > 0) {
@@ -937,7 +1062,7 @@ class RulesModule extends _BaseModule.BaseModule {
           if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
           if (!discount.isSelected) return false;
         }
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType) && !isReapplyEditModeDiscountForProduct) {
+        if (['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType) && !isReapplyEditModeDiscountForProduct) {
           // 如果策略检查后没有config，说明不可用
           if (discount.config === undefined || !discount?.config?.isAvailable) {
             return false;
@@ -945,17 +1070,22 @@ class RulesModule extends _BaseModule.BaseModule {
         }
 
         // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
-        // 商品券时主商品价格为0不可用
-        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.length && (discount.tag || discount.type) === 'good_pass') return false;
+        // 全额抵扣卡在主商品价格为 0 时不可用。
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.length && (0, _entitlementPass.isFullCoveragePass)(discount)) return false;
 
         // 折扣卡商品价格为0时不可用
-        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.find(n => n.discount?.resource_id === discount.id) && (discount.tag || discount.type) !== 'good_pass') return false;
-        // 如果优惠券已被使用，则跳过
-        const targetUsedDiscounts = usedDiscounts.get(discount.id);
-        if (targetUsedDiscounts && (discount.tag || discount.type) === 'good_pass') return false;
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.find(n => n.discount?.resource_id === discount.id) && !(0, _entitlementPass.isFullCoveragePass)(discount)) return false;
+        // good_pass 保持一张实例只使用一次。
+        if ((discount.tag || discount.type) === 'good_pass' && usedDiscounts.get(discount.id)) {
+          return false;
+        }
+        // 有限次数卡按后端实时 balance 约束本次新增分配；无限卡不看余额。
+        if ((0, _entitlementPass.isEntitlementPass)(discount) && (0, _entitlementPass.getRemainingEntitlementUses)(discount, entitlementUsageCounts.get(discount.id) || 0, 1) <= 0) {
+          return false;
+        }
 
         // 🔥 检查 maxUsagePerOrder 限制：同一 product_id 的商品券使用数量不能超过配置值
-        if ((discount.tag || discount.type) === 'good_pass') {
+        if ((0, _entitlementPass.isFullCoveragePass)(discount)) {
           const maxUsagePerOrder = discount.config?.maxUsagePerOrder;
           if (maxUsagePerOrder && maxUsagePerOrder > 0) {
             const currentUsedCount = usedProductIdCounts.get(discount.product_id) || 0;
@@ -1003,28 +1133,28 @@ class RulesModule extends _BaseModule.BaseModule {
       // 用户显式点击某张卡券时，本次选择优先于自动排序和扫码默认选择。
       // 目标仍必须在当前商品的 applicableDiscounts 中，因此不会绕过 Holder、时间或商品范围校验。
       const explicitlySelectedDiscount = options?.isSelected === true && options.discountId !== undefined ? applicableDiscounts.find(discount => {
-        const discountType = discount.tag || discount.type;
-        return String(discount.id) === String(options.discountId) && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+        const discountType = discount.tag || discount.type || '';
+        return String(discount.id) === String(options.discountId) && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
       }) : undefined;
       // 折扣卡会复用于整条商品行；商品券必须继续按单张拆分，不能复用该分支。
-      const explicitlySelectedDiscountCard = explicitlySelectedDiscount && (explicitlySelectedDiscount.tag || explicitlySelectedDiscount.type) !== 'good_pass' ? explicitlySelectedDiscount : undefined;
+      const explicitlySelectedDiscountCard = explicitlySelectedDiscount && !(0, _entitlementPass.isFullCoveragePass)(explicitlySelectedDiscount) ? explicitlySelectedDiscount : undefined;
 
       // 商品数量等变化会触发无 discountId 的重算。只要当前行已应用的折扣卡仍在
       // applicableDiscounts 中，就应保留该行选择，避免被自动排序中力度更大的卡替换。
       const appliedDiscountCardIds = new Set((product.discount_list || []).filter(item => ['discount_card', 'product_discount_card'].includes(item?.tag || item?.type)).map(item => item?.discount?.resource_id ?? item?.resource_id ?? item?.id).filter(id => id !== undefined && id !== null).map(String));
       const appliedDiscountCard = options?.scan ? undefined : applicableDiscounts.find(discount => {
-        const discountType = discount.tag || discount.type;
+        const discountType = discount.tag || discount.type || '';
         return discount.isSelected === true && ['discount_card', 'product_discount_card'].includes(discountType) && appliedDiscountCardIds.has(String(discount.id));
       });
 
-      // 优先级：本次显式选择 > 当前行既有选择 > 扫码选择 > 自动排序第一项。
-      const scannedSelectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && (n.tag || n.type) !== 'good_pass');
+      // Entitlement Pass 始终按协议优先级使用；没有新卡时沿用原选择优先级。
+      const scannedSelectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && !(0, _entitlementPass.isFullCoveragePass)(n));
       const selectedDiscountCard = explicitlySelectedDiscountCard || appliedDiscountCard || scannedSelectedDiscountCard;
-      const selectedDiscount = explicitlySelectedDiscount || selectedDiscountCard || applicableDiscounts[0];
-      const prioritizedApplicableDiscounts = explicitlySelectedDiscount && (explicitlySelectedDiscount.tag || explicitlySelectedDiscount.type) === 'good_pass' ? [explicitlySelectedDiscount, ...applicableDiscounts.filter(discount => {
-        const discountType = discount.tag || discount.type;
-        return discountType === 'good_pass' && String(discount.id) !== String(explicitlySelectedDiscount.id);
-      }), ...applicableDiscounts.filter(discount => (discount.tag || discount.type) !== 'good_pass')] : applicableDiscounts;
+      const highestPriorityEntitlementPass = applicableDiscounts.find(discount => (0, _entitlementPass.isEntitlementPass)(discount));
+      const selectedDiscount = highestPriorityEntitlementPass || explicitlySelectedDiscount || selectedDiscountCard || applicableDiscounts[0];
+      const prioritizedApplicableDiscounts = !highestPriorityEntitlementPass && explicitlySelectedDiscount && (0, _entitlementPass.isFullCoveragePass)(explicitlySelectedDiscount) ? [explicitlySelectedDiscount, ...applicableDiscounts.filter(discount => {
+        return (0, _entitlementPass.isFullCoveragePass)(discount) && String(discount.id) !== String(explicitlySelectedDiscount.id);
+      }), ...applicableDiscounts.filter(discount => !(0, _entitlementPass.isFullCoveragePass)(discount))] : applicableDiscounts;
 
       // 如果是手动折扣，则不适用优惠券
       let isManualDiscount = false;
@@ -1140,19 +1270,13 @@ class RulesModule extends _BaseModule.BaseModule {
         return;
       }
 
-      // 是否需要拆分（商品券需要拆分）
-      const isNeedSplit = (selectedDiscount.tag || selectedDiscount.type) === 'good_pass';
+      // good_pass 与 Entitlement Pass 都沿用全额抵扣卡的商品行拆分机制。
+      const isNeedSplit = (0, _entitlementPass.isFullCoveragePass)(selectedDiscount);
 
       // 需要拆分出来的数量
       const totalQuantity = product.quantity || product.num || 1;
-      const availableGoodPassCount = applicableDiscounts.filter(item => (item.tag || item.type) === 'good_pass').length;
-
-      // 🔥 如果selectedDiscount有config配置，则使用config.maxUsagePerOrder限制使用次数
-      let maxUsageLimit = availableGoodPassCount;
-      if (selectedDiscount.config && selectedDiscount.config.maxUsagePerOrder) {
-        maxUsageLimit = Math.min(availableGoodPassCount, selectedDiscount.config.maxUsagePerOrder);
-      }
-      const splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, maxUsageLimit) : 1;
+      const fullCoveragePassUsageGroups = isNeedSplit ? buildFullCoveragePassUsageGroups(prioritizedApplicableDiscounts, totalQuantity) : [];
+      const splitCount = isNeedSplit ? fullCoveragePassUsageGroups.reduce((total, group) => total + group.count, 0) : 1;
       const arr = [];
 
       // 🔥 主商品和bundle子商品分别处理
@@ -1160,22 +1284,22 @@ class RulesModule extends _BaseModule.BaseModule {
         // 主商品：保持原有逻辑
         if (splitCount < totalQuantity && isNeedSplit) {
           const remainingQuantity = totalQuantity - splitCount;
-          const applicableNonGoodPassById = new Map(applicableDiscounts.filter(discount => (discount.tag || discount.type) !== 'good_pass').map(discount => [String(discount.id), discount]));
+          const applicableNonFullCoveragePassById = new Map(applicableDiscounts.filter(discount => !(0, _entitlementPass.isFullCoveragePass)(discount)).map(discount => [String(discount.id), discount]));
           const remainderDiscountList = (product.discount_list || []).filter(discount => {
             const discountType = discount.tag || discount.type;
             if (discountType === 'promotion') return true;
-            if (discountType === 'good_pass') return false;
+            if ((0, _entitlementPass.isFullCoveragePass)(discount)) return false;
             const resourceId = discount.discount?.resource_id ?? discount.id;
-            return resourceId !== undefined && resourceId !== null && applicableNonGoodPassById.has(String(resourceId));
+            return resourceId !== undefined && resourceId !== null && applicableNonFullCoveragePassById.has(String(resourceId));
           }).map(discount => {
             if ((discount.tag || discount.type) === 'promotion') return discount;
             const resourceId = discount.discount?.resource_id ?? discount.id;
-            const matchedDiscount = applicableNonGoodPassById.get(String(resourceId));
+            const matchedDiscount = applicableNonFullCoveragePassById.get(String(resourceId));
             if (matchedDiscount) {
               // 实际场景：3 件折扣卡商品中拆出 1 件改用商品券后，
               // 剩余 2 件仍在使用原折扣卡；必须同步登记折扣卡的使用状态，
               // 否则 updatedDiscountList 会把它改成未选中并清空 savedAmount。
-              usedDiscounts.set(matchedDiscount.id, true);
+              markDiscountUsed(matchedDiscount);
               const appliedProducts = appliedDiscountProducts.get(matchedDiscount.id) || [];
               appliedProducts.push({
                 ...discount,
@@ -1189,14 +1313,14 @@ class RulesModule extends _BaseModule.BaseModule {
               _num: remainingQuantity
             };
           });
-          const hasRetainedWalletDiscount = remainderDiscountList.some(discount => !['promotion', 'good_pass'].includes(discount.tag || discount.type));
+          const hasRetainedWalletDiscount = remainderDiscountList.some(discount => (discount.tag || discount.type) !== 'promotion' && !(0, _entitlementPass.isFullCoveragePass)(discount));
           let total = product.origin_total ?? product.total;
           if ((product.discount_list || []).some(item => item.type === 'promotion')) {
             total = product.total ?? product.origin_total;
           }
           arr.push(this.hooks.setProduct(originProduct, {
             // 商品券只替换被拆出的 splitCount 件。余量行原本仍有效的折扣卡
-            // 不能随 good_pass 拆分一起清除；已取消或已失效的折扣不会进入此列表。
+            // 不能随全额抵扣卡拆分一起清除；已取消或已失效的折扣不会进入此列表。
             discount_list: remainderDiscountList,
             quantity: remainingQuantity,
             _id: product._id.split('___')[0],
@@ -1208,14 +1332,21 @@ class RulesModule extends _BaseModule.BaseModule {
             } : {})
           }));
         }
-        for (let i = 0; i < splitCount; i++) {
-          const selectedDiscount = isNeedSplit ? prioritizedApplicableDiscounts[i] : selectedDiscountCard || applicableDiscounts[i];
+        const discountUsageGroups = isNeedSplit ? fullCoveragePassUsageGroups : [{
+          discount: selectedDiscount,
+          count: 1
+        }];
+        for (let i = 0; i < discountUsageGroups.length; i++) {
+          const {
+            discount: selectedDiscount,
+            count: appliedUseCount
+          } = discountUsageGroups[i];
           // 标记优惠券为已使用
-          usedDiscounts.set(selectedDiscount.id, true);
+          markDiscountUsed(selectedDiscount, appliedUseCount);
           // 🔥 更新 product_id 使用计数
-          if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+          if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
             const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
-            usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
+            usedProductIdCounts.set(selectedDiscount.product_id, currentCount + appliedUseCount);
           }
 
           // 记录实际应用了优惠券的商品信息
@@ -1277,7 +1408,7 @@ class RulesModule extends _BaseModule.BaseModule {
           const mainProductDiscountAmount = amount;
           const lineDiscountAmount = new _decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
           const discountType = selectedDiscount.tag || selectedDiscount.type;
-          const isGoodPass = discountType === 'good_pass';
+          const isFullCoverage = (0, _entitlementPass.isFullCoveragePass)(selectedDiscount);
           const discountDetail = {
             amount: lineDiscountAmount,
             type: selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : discountType,
@@ -1293,10 +1424,10 @@ class RulesModule extends _BaseModule.BaseModule {
               discount_product_id: selectedDiscount.product_id
             },
             // 前端使用的num数量，为了计算优惠金额
-            _num: isGoodPass ? 1 : product.num,
+            _num: isFullCoverage ? appliedUseCount : product.num,
             config: selectedDiscount?.config,
             metadata: {
-              num: 1,
+              num: isFullCoverage ? appliedUseCount : 1,
               discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
               // 🔥 order_level 分摊差值
               ...(productDiscountDifference !== undefined && {
@@ -1315,9 +1446,9 @@ class RulesModule extends _BaseModule.BaseModule {
           if (product.isClient) {
             arr.push(this.hooks.setProduct(originProduct, {
               discount_list: [discountDetail],
-              // good_pass：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
-              price: isGoodPass ? mainProductSellingPrice : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
+              // 全额抵扣卡：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
+              price: isFullCoverage ? mainProductSellingPrice : product.price,
+              quantity: isNeedSplit ? appliedUseCount : product.quantity,
               origin_total: (0, _utils2.getProductOriginTotalPrice)({
                 product: {
                   original_price: product.original_price
@@ -1334,8 +1465,8 @@ class RulesModule extends _BaseModule.BaseModule {
             arr.push(this.hooks.setProduct(originProduct, {
               discount_list: this.filterDiscountListByType(product.discount_list, 'promotion').concat([discountDetail]),
               _id: product._id.split('___')[0] + '___' + selectedDiscount.id + index,
-              price: selectedDiscount.tag === 'good_pass' ? 0 : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
+              price: isFullCoverage ? 0 : product.price,
+              quantity: isNeedSplit ? appliedUseCount : product.quantity,
               total: total,
               origin_total: productOriginTotal,
               main_product_selling_price: mainProductSellingPrice,
@@ -1352,14 +1483,17 @@ class RulesModule extends _BaseModule.BaseModule {
           const discountNum = splitCount;
           const normalNum = totalQuantity - discountNum;
 
-          // 生成有折扣的商品（每张商品券对应 num: 1）
-          for (let i = 0; i < discountNum; i++) {
-            const selectedDiscount = prioritizedApplicableDiscounts[i];
-            usedDiscounts.set(selectedDiscount.id, true);
+          // 同一卡实例的本次新增使用合并为一条，metadata.num 记录实际次数。
+          for (let i = 0; i < fullCoveragePassUsageGroups.length; i++) {
+            const {
+              discount: selectedDiscount,
+              count: appliedUseCount
+            } = fullCoveragePassUsageGroups[i];
+            markDiscountUsed(selectedDiscount, appliedUseCount);
             // 🔥 更新 product_id 使用计数
-            if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+            if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
               const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
-              usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
+              usedProductIdCounts.set(selectedDiscount.product_id, currentCount + appliedUseCount);
             }
 
             // 🔥 生成唯一的 _id
@@ -1367,11 +1501,12 @@ class RulesModule extends _BaseModule.BaseModule {
 
             // 计算折扣后的价格（使用 getDiscountAmount，内部已处理 maxDeductionAmount）
             const discountedPrice = (0, _utils.getDiscountAmount)(selectedDiscount, product.origin_total, product.origin_total);
-            const bundleDiscountAmount = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            const bundleDiscountAmountPerItem = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            const bundleDiscountAmount = new _decimal.default(bundleDiscountAmountPerItem).mul(appliedUseCount).toNumber();
             debugger;
             const discountDetail = {
               amount: bundleDiscountAmount,
-              type: 'good_pass',
+              type: selectedDiscount.tag || selectedDiscount.type,
               discount: {
                 fixed_amount: product.origin_total,
                 discount_calculation_mode: selectedDiscount?.metadata?.discount_calculation_mode,
@@ -1385,9 +1520,9 @@ class RulesModule extends _BaseModule.BaseModule {
                 // 🔥 使用拆分后的唯一 _id
                 custom_product_bundle_map_id: uniqueId,
                 discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
-                num: 1
+                num: appliedUseCount
               },
-              _num: 1,
+              _num: appliedUseCount,
               config: selectedDiscount?.config
             };
 
@@ -1399,11 +1534,11 @@ class RulesModule extends _BaseModule.BaseModule {
               ...flatItem,
               // 🔥 使用唯一的 _id
               _id: uniqueId,
-              num: 1,
-              quantity: 1,
+              num: appliedUseCount,
+              quantity: appliedUseCount,
               price: discountedPrice,
               // 折扣后的价格
-              total: discountedPrice,
+              total: new _decimal.default(discountedPrice).mul(appliedUseCount).toNumber(),
               discount_list: [discountDetail],
               processed: true,
               _discountId: selectedDiscount.id
@@ -1425,9 +1560,9 @@ class RulesModule extends _BaseModule.BaseModule {
         } else {
           // 折扣卡：不拆分数量，直接应用
           const selectedDiscount = selectedDiscountCard || applicableDiscounts[0];
-          usedDiscounts.set(selectedDiscount.id, true);
+          markDiscountUsed(selectedDiscount);
           // 🔥 更新 product_id 使用计数（虽然此处主要是折扣卡，但保持一致性）
-          if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+          if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
             const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
             usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
           }
@@ -1560,11 +1695,10 @@ class RulesModule extends _BaseModule.BaseModule {
           // 没有bundle，直接使用主商品处理结果
           result.push(...mainProductArr);
         } else {
-          // 🔥 有bundle，需要检查子商品是否应用了商品券
+          // 🔥 有 bundle，需要检查子商品是否应用了全额抵扣卡
           // 1. 先收集所有bundle子商品的处理结果
           const bundleProcessingInfo = new Map();
-          let hasGoodPassApplied = false; // 标记是否有子商品应用了商品券
-
+          let hasFullCoveragePassApplied = false;
           if (product.bundle && Array.isArray(product.bundle)) {
             product.bundle.forEach((bundleItem, bundleIndex) => {
               const bundleItemId = `${product._id}_bundle_${bundleIndex}`;
@@ -1575,10 +1709,9 @@ class RulesModule extends _BaseModule.BaseModule {
               } else {
                 // 处理过的bundle item
                 bundleProcessingInfo.set(bundleIndex, processedBundleItems);
-                // 🔥 检查是否应用了商品券（good_pass）
-                const hasGoodPass = processedBundleItems.some(item => item.discount_list?.some(discount => discount.type === 'good_pass' || discount.tag === 'good_pass'));
-                if (hasGoodPass) {
-                  hasGoodPassApplied = true;
+                const hasFullCoveragePass = processedBundleItems.some(item => item.discount_list?.some(discount => (0, _entitlementPass.isFullCoveragePass)(discount)));
+                if (hasFullCoveragePass) {
+                  hasFullCoveragePassApplied = true;
                 }
               }
             });
@@ -1586,7 +1719,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
           // 🔥 2. 如果有子商品应用了商品券，且主商品数量大于1，需要拆分主商品
           const mainProductQuantity = mainProductArr[0] ? this.hooks.getProduct(mainProductArr[0]).quantity : 1;
-          if (hasGoodPassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
+          if (hasFullCoveragePassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
             const mainProduct = mainProductArr[0];
             const mainProductData = this.hooks.getProduct(mainProduct);
 
@@ -1890,6 +2023,8 @@ class RulesModule extends _BaseModule.BaseModule {
 
       // 获取此优惠券实际应用的商品详情
       const appliedProductDetails = appliedDiscountProducts.get(discount.id) || [];
+      const committedAppliedProductDetails = (0, _entitlementPass.isEntitlementPass)(discount) ? mergeEntitlementAppliedProductDetails(discount.committedAppliedProductDetails || []) : [];
+      const allAppliedProductDetails = (0, _entitlementPass.isEntitlementPass)(discount) ? mergeEntitlementAppliedProductDetails([...committedAppliedProductDetails, ...appliedProductDetails]) : appliedProductDetails;
 
       // 根据是否有适用商品决定isAvailable
       const isAvailable = applicableProducts.length > 0;
@@ -1904,11 +2039,11 @@ class RulesModule extends _BaseModule.BaseModule {
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
           applicableProductDetails: applicableProductDetails,
-          // 添加实际抵扣的商品详情（对于未选中的优惠券，为空数组）
-          appliedProductDetails: []
+          // 已提交的历史使用不可撤销；只取消本次新增分配。
+          appliedProductDetails: committedAppliedProductDetails
         };
       }
-      if (usedDiscounts.get(discount.id)) {
+      if (isDiscountUsed(discount)) {
         return {
           ...discount,
           isSelected: true,
@@ -1920,7 +2055,7 @@ class RulesModule extends _BaseModule.BaseModule {
           // 添加可抵扣的商品详情
           applicableProductDetails: applicableProductDetails,
           // 添加实际抵扣的商品详情
-          appliedProductDetails: appliedProductDetails
+          appliedProductDetails: allAppliedProductDetails
         };
       }
       let isSelected = typeof discount.isSelected === 'boolean' ? discount.isSelected : undefined;
@@ -1928,7 +2063,7 @@ class RulesModule extends _BaseModule.BaseModule {
       // 如果是可用的 并且没有手动标记 则设置为选中
       if (isAvailable && appliedProductDetails.length && !discount.isManualSelect) {
         isSelected = true;
-      } else if (!appliedProductDetails.length) {
+      } else if (!appliedProductDetails.length && !committedAppliedProductDetails.length) {
         isSelected = false;
       }
       return {
@@ -1942,8 +2077,8 @@ class RulesModule extends _BaseModule.BaseModule {
         applicableProductIds: applicableProducts,
         // 添加可抵扣的商品详情
         applicableProductDetails: applicableProductDetails,
-        // 添加实际抵扣的商品详情（对于未使用的优惠券，为空数组）
-        appliedProductDetails: []
+        // 编辑订单的历史使用继续保留，本次没有新增使用。
+        appliedProductDetails: committedAppliedProductDetails
       };
     });
     return {