@pisell/pisellos 0.0.568 → 0.0.570

package/lib/modules/Rules/index.js

@@ -44,7 +44,8 @@ class RulesModule extends _BaseModule.BaseModule {
     // 非表单类型 holder 视为匹配
     if (discount.holder?.holder_type !== 'form') return true;
     // 主预约holder, 目前（20251124）默认只考虑单个holder的情况
-    const orderHolderId = Array.isArray(holders) && holders.length > 0 ? holders[0].form_record_id : undefined;
+    // 旧版 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;
@@ -92,8 +93,8 @@ class RulesModule extends _BaseModule.BaseModule {
     const result = this.calcDiscount({
       discountList: mergedDiscountList,
       productList: [...productList],
-      holders,
       orderTotalAmount,
+      holders,
       isFormSubject
     }, {
       scan: true
@@ -138,6 +139,15 @@ class RulesModule extends _BaseModule.BaseModule {
     return (discountList || []).filter(item => item.type === type || item.tag === type);
   }
 
+  /** 剔除指定 type/tag 的折扣项，保留手动改价(type=product) / 券等 */
+  excludeDiscountListByType(discountList, type) {
+    return (discountList || []).filter(item => item.type !== type && item.tag !== type);
+  }
+
+  /** 手动改价场景：去掉 promotion，保留 type=product 等行内折扣 */
+  resolveDiscountListForManualOverride(discountList) {
+    return this.excludeDiscountListByType(discountList, 'promotion');
+  }
   // 获取券不可用的原因
   getUnavailableReason(discountList, productList) {
     // 检查时间限制
@@ -179,6 +189,33 @@ class RulesModule extends _BaseModule.BaseModule {
     isFormSubject,
     orderTotalAmount
   }, options) {
+    const resolveIsFormSubject = product => typeof isFormSubject === 'function' ? Boolean(isFormSubject(product)) : Boolean(isFormSubject);
+
+    // 识别出来是不是在编辑的界面里又新增了商品
+    // 这种情况下，如果有可用的优惠券，也会自动勾选上
+    const isEditModeAddNewProduct = productList.find(n => n.booking_id) && productList.find(n => !n.booking_id);
+    const reapplyBookingDiscountProductUids = new Set((options?.reapplyBookingDiscountProductUids || []).filter(uid => uid !== undefined && uid !== null && uid !== '').map(String));
+    const getOriginProductUid = originProduct => {
+      const uid = originProduct?.metadata?.unique_identification_number ?? originProduct?.unique_identification_number;
+      if (uid === undefined || uid === null || uid === '') return undefined;
+      return String(uid);
+    };
+    const shouldReapplyBookingDiscount = (originProduct, selectedDiscount) => {
+      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 resolveReapplyEditModeDiscountPercent = (originProduct, selectedDiscount) => {
+      if (!shouldReapplyBookingDiscount(originProduct, selectedDiscount)) return undefined;
+      const discountType = selectedDiscount?.tag || selectedDiscount?.type;
+      if (discountType !== 'discount_card' && discountType !== 'product_discount_card') {
+        return undefined;
+      }
+      const percent = Number(selectedDiscount.discount?.percent);
+      return Number.isFinite(percent) ? percent : undefined;
+    };
     const editModeDiscount = [];
     const addModeDiscount = [];
     discountList.forEach(discount => {
@@ -205,11 +242,21 @@ class RulesModule extends _BaseModule.BaseModule {
         }
       });
     }
+    const hasDiscountInput = editModeDiscount.length > 0 || addModeDiscount.length > 0 || Boolean(options?.discountId) || Boolean(options?.selectedList?.length) || Boolean(options?.scan);
+    if (!hasDiscountInput) {
+      return {
+        discountList,
+        productList
+      };
+    }
+    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);
+    };
 
-    // 过滤掉手动取消false的优惠券，但仅用于应用优惠逻辑
-    const filteredDiscountList = addModeDiscount.filter(discount => {
-      return !discount.isManualSelect;
-    });
+    // 过滤掉手动取消false的优惠券，但仅用于应用优惠逻辑。
+    // Change time 重报价需要把已选编辑态折扣卡重新放入候选，再由目标 uid 限定作用范围。
+    const filteredDiscountList = [...addModeDiscount.filter(discount => !discount.isManualSelect), ...editModeDiscount.filter(canUseEditModeDiscountForReapply)];
 
     // 🔥 扁平化商品列表：将 bundle 子商品展开为虚拟商品
     const flattenProductsWithBundle = productList => {
@@ -378,10 +425,6 @@ class RulesModule extends _BaseModule.BaseModule {
     // 🔥 扁平化商品列表（包含主商品和bundle子商品）
     const flattenedList = flattenProductsWithBundle(productList);
 
-    // 识别出来是不是在编辑的界面里又新增了商品
-    // 这种情况下，如果有可用的优惠券，也会自动勾选上
-    const isEditModeAddNewProduct = flattenedList.find(n => n.booking_id) && flattenedList.find(n => !n.booking_id);
-
     // 对扁平化后的列表按价格降序排序（用于应用优惠券时优先选择高价商品）
     const sortedFlattenedList = flattenedList.sort((a, b) => {
       // 子商品优先使用 original_price，主商品使用 price
@@ -625,6 +668,7 @@ class RulesModule extends _BaseModule.BaseModule {
         }
       }
     });
+
     // 🔥 第三步：识别 order_level 折扣卡并预计算分摊（排除被其他专属折扣卡占用的商品）
     sortedDiscountList.forEach(discount => {
       if (!(0, _utils.isOrderLevelFixedAmountDiscount)(discount)) {
@@ -719,7 +763,7 @@ class RulesModule extends _BaseModule.BaseModule {
         // 拿到discount配置的holder信息 product信息 product.holder 加在 isLimitedProduct
         const _tempVar = flatItem?.type === 'bundle' ? flatItem?.parentProduct : flatItem?.product;
         const isHolderMatch = this.checkHolderMatch(discount, {
-          isNeedHolder: isFormSubject && !_tempVar?.isNormalProduct,
+          isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
           holder_id: _tempVar?.holder_id || product.holder_id
         }, holders);
         let timeLimit = true;
@@ -757,7 +801,7 @@ class RulesModule extends _BaseModule.BaseModule {
               title: discount.format_title,
               original_amount: product.price || product.origin_total,
               pre_value: discount.par_value,
-              product_id: originProduct.id,
+              product_id: originProduct.id || originProduct.product_id,
               discount_product_id: discount.product_id
             },
             metadata: {
@@ -858,9 +902,15 @@ class RulesModule extends _BaseModule.BaseModule {
         };
         originProduct = flatItem.originProduct;
       }
+      const isPersistedProduct = product?.booking_id || originProduct?.order_detail_id || originProduct?.orderDetailId || originProduct?.booking_id;
+      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));
+      });
 
-      // 已有优惠的商品跳过
-      if (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))) {
+      // 已持久化且已有钱包券/折扣卡的商品行跳过，保留后端历史折扣结果。
+      if (isPersistedProduct && hasExistingWalletDiscount) {
         if (flatItem.type === 'main') {
           processedProductsMap.set(product._id, [originProduct]);
         } else {
@@ -876,7 +926,14 @@ class RulesModule extends _BaseModule.BaseModule {
       const applicableDiscounts = sortedDiscountList.filter(discount => {
         // 🔥 检查策略可用性（针对 good_pass 和折扣卡）
         const discountType = discount.tag || discount.type;
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
+        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) {
+          const uid = currentOriginUid;
+          if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
+          if (!discount.isSelected) return false;
+        }
+        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType) && !isReapplyEditModeDiscountForProduct) {
           // 如果策略检查后没有config，说明不可用
           if (discount.config === undefined || !discount?.config?.isAvailable) {
             return false;
@@ -920,7 +977,7 @@ class RulesModule extends _BaseModule.BaseModule {
         // 拿到discount配置的holder信息 product信息 product.holder 不可用return false
         const _tempVar = flatItem?.type === 'bundle' ? flatItem?.parentProduct : flatItem?.product;
         const isHolderMatch = this.checkHolderMatch(discount, {
-          isNeedHolder: isFormSubject && !_tempVar?.isNormalProduct,
+          isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
           holder_id: _tempVar?.holder_id || product.holder_id
         }, holders);
         // 如果 holder 不匹配，则不适用
@@ -962,7 +1019,7 @@ class RulesModule extends _BaseModule.BaseModule {
       let isManualDiscount = false;
       if (flatItem.type === 'main') {
         // 主商品：判断自身是否手动折扣
-        isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.total != product.origin_total && (product.bundle || []).every(item => !(item.discount_list || [])?.length) && (!product.discount_list?.length || product?.discount_list?.every?.(item => item.type === 'product'));
+        isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.discount_list?.some(item => item.type === 'product') || product.total != product.origin_total && (product.bundle || []).every(item => !(item.discount_list || [])?.length) && (!product.discount_list?.length || product?.discount_list?.every?.(item => item.type === 'product'));
         if (product.inPromotion) {
           isManualDiscount = false;
         }
@@ -970,7 +1027,7 @@ class RulesModule extends _BaseModule.BaseModule {
         // bundle子商品：判断父主商品是否手动折扣
         const parentProduct = flatItem.parentProduct;
         if (parentProduct) {
-          isManualDiscount = typeof parentProduct.isManualDiscount === 'boolean' ? parentProduct.isManualDiscount : parentProduct.total != parentProduct.origin_total && (parentProduct.bundle || []).every(item => !(item.discount_list || [])?.length) && (!parentProduct.discount_list?.length || parentProduct?.discount_list?.every?.(item => item.type === 'product'));
+          isManualDiscount = typeof parentProduct.isManualDiscount === 'boolean' ? parentProduct.isManualDiscount : parentProduct.discount_list?.some(item => item.type === 'product') || parentProduct.total != parentProduct.origin_total && (parentProduct.bundle || []).every(item => !(item.discount_list || [])?.length) && (!parentProduct.discount_list?.length || parentProduct?.discount_list?.every?.(item => item.type === 'product'));
         }
       }
 
@@ -1027,7 +1084,7 @@ class RulesModule extends _BaseModule.BaseModule {
                 price: product.price,
                 options: restoredOptions
               }),
-              discount_list: this.filterDiscountListByType(product.discount_list, 'promotion')
+              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, 'promotion')
             })]);
           } else {
             let total = product.inPromotion ? product?._promotion?.finalPrice ?? product.origin_total ?? product.total : product.origin_total ?? product.total;
@@ -1042,26 +1099,26 @@ class RulesModule extends _BaseModule.BaseModule {
               } : {
                 _id: product._id.split('___')[0] + '___' + index,
                 total,
-                original_price: product.original_price,
                 price: product.price,
                 main_product_selling_price,
                 options: restoredOptions
               }),
-              discount_list: this.filterDiscountListByType(product.discount_list, 'promotion')
+              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, 'promotion')
             })]);
           }
         } else {
           // bundle子商品：保存到扁平化Map
           processedFlatItemsMap.set(flatItem._id, [{
             ...flatItem,
-            discount_list: this.filterDiscountListByType(flatItem.bundleItem?.discount_list || [], 'promotion'),
+            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,
             processed: true
           }]);
         }
         return;
       }
-      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === 'undefined' && !options?.scan && !isEditModeAddNewProduct) {
+      const shouldReapplyBookingDiscountForProduct = shouldReapplyBookingDiscount(originProduct, selectedDiscount);
+      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === 'undefined' && !options?.scan && !isEditModeAddNewProduct && !shouldReapplyBookingDiscountForProduct) {
         return;
       }
 
@@ -1158,18 +1215,25 @@ class RulesModule extends _BaseModule.BaseModule {
           let productDiscountDifference;
           let discountedOptions = product.options;
           let optionDiscountAmount = 0;
+          let reapplyDiscountPercent;
           if (isOrderLevel && productAllocation) {
             // order_level：使用预计算的分摊金额
             amount = productAllocation.discountAmount;
             productDiscountDifference = productAllocation.difference;
             mainProductSellingPrice = Math.max(new _decimal.default(product.price).minus(amount).toNumber(), 0);
+          } else if (resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount) !== undefined) {
+            // Change time 重套编辑态折扣卡时，历史 par_value 不是运行时折扣口径，优先使用后端快照里的 percent。
+            const percent = resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount);
+            reapplyDiscountPercent = new _decimal.default(percent).toFixed(2);
+            mainProductSellingPrice = new _decimal.default(product.price || 0).mul(new _decimal.default(100).minus(percent)).div(100).toDecimalPlaces(2).toNumber();
+            amount = new _decimal.default(product.price).minus(mainProductSellingPrice).toNumber();
           } else {
             // item_level 或其他类型：使用原有逻辑
-            mainProductSellingPrice = (0, _utils.getDiscountAmount)(currentSelectedDiscount, product.price, product.price);
+            mainProductSellingPrice = (0, _utils.getDiscountAmount)(selectedDiscount, product.price, product.price);
             amount = new _decimal.default(product.price).minus(new _decimal.default(mainProductSellingPrice)).toNumber();
           }
           if (isDeductOptionPrice && product.options?.length) {
-            const optionResult = applyDiscountToOptions(product.options, currentSelectedDiscount);
+            const optionResult = applyDiscountToOptions(product.options, selectedDiscount);
             discountedOptions = optionResult.discountedOptions;
             optionDiscountAmount = optionResult.optionDiscountAmount;
           }
@@ -1182,9 +1246,8 @@ class RulesModule extends _BaseModule.BaseModule {
           // discount_list.amount / fixed_amount：行级总优惠 = 主商品优惠 + option 优惠（与 total 变化一致）
           const mainProductDiscountAmount = amount;
           const lineDiscountAmount = new _decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
-          const currentDiscountType = currentSelectedDiscount.tag === 'product_discount_card' ? 'discount_card' : currentSelectedDiscount.tag;
           const discountType = selectedDiscount.tag || selectedDiscount.type;
-          const currentIsGoodPass = currentDiscountType === 'good_pass';
+          const currentIsGoodPass = discountType === 'good_pass';
           const discountDetail = {
             amount: lineDiscountAmount,
             type: selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : discountType,
@@ -1195,9 +1258,9 @@ class RulesModule extends _BaseModule.BaseModule {
               resource_id: selectedDiscount.id,
               title: selectedDiscount.format_title,
               original_amount: product.price,
-              product_id: originProduct.id,
-              percent: currentSelectedDiscount.par_value,
-              discount_product_id: currentSelectedDiscount.product_id
+              product_id: originProduct.id || originProduct.product_id,
+              percent: reapplyDiscountPercent ?? selectedDiscount.par_value,
+              discount_product_id: selectedDiscount.product_id
             },
             // 前端使用的num数量，为了计算优惠金额（拆分时为1）
             _num: isNeedSplit ? 1 : product.num,
@@ -1215,7 +1278,7 @@ class RulesModule extends _BaseModule.BaseModule {
             }
           };
           appliedProducts.push(discountDetail);
-          appliedDiscountProducts.set(currentSelectedDiscount.id, appliedProducts);
+          appliedDiscountProducts.set(selectedDiscount.id, appliedProducts);
 
           // 记录应用了优惠券的商品
           // 后续更新价格改为 getProductTotalPrice getProductOriginTotalPrice逻辑
@@ -1223,7 +1286,7 @@ class RulesModule extends _BaseModule.BaseModule {
             arr.push(this.hooks.setProduct(originProduct, {
               discount_list: [discountDetail],
               // good_pass：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
-              price: currentIsGoodPass ? mainProductSellingPrice : product.price,
+              price: isGoodPass ? mainProductSellingPrice : product.price,
               quantity: isNeedSplit ? 1 : product.quantity,
               origin_total: (0, _utils2.getProductOriginTotalPrice)({
                 product: {
@@ -1283,6 +1346,7 @@ class RulesModule extends _BaseModule.BaseModule {
             // 计算折扣后的价格（使用 getDiscountAmount，内部已处理 maxDeductionAmount）
             const discountedPrice = (0, _utils.getDiscountAmount)(currentBundleDiscount, product.origin_total, product.origin_total);
             const bundleDiscountAmount = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            debugger;
 
             // 确定折扣类型
             const bundleDiscountType = currentBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : currentBundleDiscount.tag;
@@ -1296,9 +1360,8 @@ class RulesModule extends _BaseModule.BaseModule {
                 resource_id: currentBundleDiscount.id,
                 title: currentBundleDiscount.format_title,
                 original_amount: product.origin_total,
-                product_id: product.id,
-                percent: currentBundleDiscount.par_value,
-                discount_product_id: currentBundleDiscount.product_id
+                product_id: product.id || product.product_id,
+                discount_product_id: selectedDiscount.product_id
               },
               metadata: {
                 // 🔥 使用拆分后的唯一 _id
@@ -1590,6 +1653,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
           // 🔥 使用当前的 _id 作为唯一标识
           const uniqueId = flatItem._id;
+          debugger;
           const discountDetail = {
             amount: bundleActualDiscountAmount * (product.num || 1),
             type: currentBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : currentBundleDiscount.tag,
@@ -1600,9 +1664,9 @@ class RulesModule extends _BaseModule.BaseModule {
               resource_id: currentBundleDiscount.id,
               title: currentBundleDiscount.format_title,
               original_amount: product.original_price,
-              product_id: product.id,
-              percent: currentBundleDiscount.par_value,
-              discount_product_id: currentBundleDiscount.product_id
+              product_id: product.id || product.product_id,
+              percent: selectedDiscount.par_value,
+              discount_product_id: selectedDiscount.product_id
             },
             metadata: {
               // 🔥 使用唯一的 _id
@@ -1927,6 +1991,8 @@ class RulesModule extends _BaseModule.BaseModule {
                   } else {
                     // 🔥 关键：拆分后的bundle item
                     processedBundleItems.forEach(item => {
+                      const nextBundlePrice = item.price ?? bundleItem.price;
+                      const nextBundleSellingPrice = item.bundle_selling_price ?? item.price ?? bundleItem.bundle_selling_price;
                       // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
                       const updatedDiscountList = (item.discount_list || []).map(discount => ({
                         ...discount,
@@ -1941,18 +2007,20 @@ class RulesModule extends _BaseModule.BaseModule {
                         ...bundleItem,
                         _id: item._id,
                         product_id: bundleItem.product_id,
-                        price: item.price,
+                        price: nextBundlePrice,
                         num: item.num,
                         discount_list: updatedDiscountList,
-                        bundle_selling_price: bundleItem.bundle_selling_price !== undefined ? item.price : undefined
+                        bundle_selling_price: bundleItem.bundle_selling_price !== undefined ? nextBundleSellingPrice : undefined
                       });
                     });
                   }
                 });
               }
 
-              // 🔥 重新计算主商品的总价（包含bundle）
-              let newTotal = Number(mainProductData.price || 0);
+              // 主商品已经在前面的 setProduct 中应用过折扣；这里只替换 bundle，
+              // 避免把主商品 discount_list 再扣一次。
+              const mainSellingPrice = mainProductData.main_product_selling_price ?? mainProductData.price ?? 0;
+              let newTotal = Number(mainSellingPrice || 0);
               let newOriginTotal = Number(mainProductData.original_price || mainProductData.price || 0);
 
               // 判断是否是手动折扣
@@ -1963,23 +2031,18 @@ class RulesModule extends _BaseModule.BaseModule {
                 newTotal = mainProductData.total ?? newTotal;
                 newOriginTotal = mainProductData.origin_total ?? newOriginTotal;
               } else {
-                // 不是手动折扣时，才重新计算
-                const mainDiscountList = mainProductData.discount_list.filter(item => !item?.metadata?.custom_product_bundle_map_id);
-
-                // 如果主商品本身有折扣，需要重新计算主商品价格
-                if (mainDiscountList && mainDiscountList.length > 0) {
-                  const allDiscountAmount = (0, _utils.getDiscountListAmount)(mainDiscountList);
-                  newTotal = new _decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotal;
-                  newOriginTotal = mainProductData.origin_total ?? newOriginTotal;
-                }
-
-                // 累加bundle的价格（只累加一次）
+                // 累加bundle的折后价格（只累加一次）
                 if (newBundle.length > 0) {
                   newBundle.forEach(item => {
                     newTotal += Number(item.price) * Number(item.num);
                     const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
                     newOriginTotal += Number(originalPrice) * Number(item.num);
                   });
+                  // 计算原始总价（不考虑折扣）
+                  newBundle.forEach(item => {
+                    const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
+                    newOriginTotal += Number(originalPrice) * Number(item.num);
+                  });
                 }
               }
 
@@ -2102,13 +2165,14 @@ class RulesModule extends _BaseModule.BaseModule {
     // 套餐适用范围配置
     const packageScope = usageRules?.package_scope;
     const {
-      type: scopeType,
+      type: scopeType = 'product_all',
       exclude_bundle_product_ids = [],
       include_bundle_product_ids = [],
       filter = 0
     } = packageScope || {};
     const isMainProduct = flatItem.type === 'main'; // 单独购买
     const isBundleItem = flatItem.type === 'bundle'; // 套餐中购买
+    const bundleMainProductId = flatItem.product?.product_id;
 
     // 主商品直接可用
     if (isMainProduct) {
@@ -2150,13 +2214,13 @@ class RulesModule extends _BaseModule.BaseModule {
             if (!filter) {
               isScopeValid = true;
             } else {
-              isScopeValid = !exclude_bundle_product_ids.includes(Number(mainProductId));
+              isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
             }
           }
 
           // 包含套餐判断, products值兼容旧数据
           if (scopeType === 'specific_packages' || scopeType === 'products') {
-            isScopeValid = include_bundle_product_ids.includes(Number(mainProductId));
+            isScopeValid = include_bundle_product_ids.includes(Number(bundleMainProductId));
           }
 
           // 价格和套餐适用范围都符合，则可用
@@ -2205,16 +2269,43 @@ class RulesModule extends _BaseModule.BaseModule {
 
         // 检查 rules
         if (rules.length > 0) {
-          // 检查原价
-          if (isOriginalPrice && rules.includes('original_price')) {
-            return true;
+          const _isOriginalPrice = isOriginalPrice && rules.includes('original_price');
+          const _isMarkupPrice = isMarkupPrice && rules.includes('markup_price');
+          // 价格是否符合规则：原价或加价
+          const isPriceValid = _isOriginalPrice || _isMarkupPrice;
+          // 套餐适用范围校验
+          let isScopeValid = false;
+
+          // 排除套餐判断, product_all值兼容旧数据
+          if (scopeType === 'all_packages' || scopeType === 'product_all') {
+            // 所有套餐可用
+            if (!filter) {
+              isScopeValid = true;
+            } else {
+              isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
+            }
           }
 
-          // 检查加价
-          if (isMarkupPrice && rules.includes('markup_price')) {
+          // 包含套餐判断, products值兼容旧数据
+          if (scopeType === 'specific_packages' || scopeType === 'products') {
+            isScopeValid = include_bundle_product_ids.includes(Number(bundleMainProductId));
+          }
+
+          // 价格和套餐适用范围都符合，则可用
+          if (isPriceValid && isScopeValid) {
             return true;
           }
 
+          // 检查原价
+          // if (isOriginalPrice && rules.includes('original_price')) {
+          //   return true;
+          // }
+
+          // 检查加价
+          // if (isMarkupPrice && rules.includes('markup_price')) {
+          //   return true;
+          // }
+
           // 如果都不匹配，则不可用
           return false;
         }
@@ -2283,6 +2374,7 @@ class RulesModule extends _BaseModule.BaseModule {
   async destroy() {
     this.core.effects.offByModuleDestroy(this.name);
     await this.core.effects.emit(`${this.name}:onDestroy`, {});
+    super.destroy();
   }
   async clear() {}
 }

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

@@ -1,4 +1,5 @@
 import { Discount } from '../Discount/types';
+import { SetDiscountSelectedParams } from '../../solution/ShopDiscount/types';
 export declare enum UnavailableReason {
     TimeLimit = "time_limit",
     ProductNotApplicable = "product_not_applicable",
@@ -22,6 +23,15 @@ export interface DiscountResult {
     productList: any[];
     discountList: any[];
 }
+export declare type RulesFormSubject = boolean | ((product: any) => boolean);
+export interface RulesCalcDiscountOptions {
+    isSelected?: boolean;
+    discountId?: number;
+    selectedList?: SetDiscountSelectedParams[];
+    scan?: boolean;
+    /** Change time 重报价目标行：允许已选编辑态折扣卡重新应用到这些 booking 商品。 */
+    reapplyBookingDiscountProductUids?: string[];
+}
 export interface RulesModuleAPI {
     setRulesList: (rulesList: Rules[]) => Promise<void>;
     clear: () => Promise<void>;
@@ -31,11 +41,11 @@ export interface RulesModuleAPI {
         holders: {
             form_record_id: number;
         }[];
-        isFormSubject: boolean;
+        isFormSubject: RulesFormSubject;
         orderTotalAmount: number;
-    }) => DiscountResult;
+    }, options?: RulesCalcDiscountOptions) => DiscountResult;
 }
-type ProductDetail = {
+declare type ProductDetail = {
     isClient?: boolean;
     isManualDiscount?: boolean;
     booking_id: any;
@@ -51,8 +61,9 @@ type ProductDetail = {
     num?: number;
     quantity: number;
     vouchersApplicable?: boolean;
-    holder_id?: number | string;
+    holder_id?: number;
     startDate?: any;
+    main_product_selling_price?: number | string;
 };
 export interface RulesParamsHooks {
     getProduct: (product: Record<string, any>) => ProductDetail;

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

@@ -5,19 +5,35 @@ export * from './types';
 export declare class SalesSummaryModule extends BaseModule implements Module, SalesSummaryModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    private shopStore;
+    private appPlugin;
     private store;
     private request;
+    private surchargeListModuleName;
+    private otherParams;
+    private surchargeListChannel;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    getSurchargeList(): Promise<void>;
+    /**
+     * 更新父级解决方案透传的运行态参数，并在 surcharge 模块名或渠道变化时刷新附加费列表。
+     *
+     * @example
+     * await salesSummaryModule.updateOtherParams({ channel: 'pos', surchargeListModuleName: 'custom_surchargeList' });
+     */
+    updateOtherParams(params: Record<string, any>): Promise<void>;
+    private resolveChannel;
+    getSurchargeList(channel?: string): Promise<void>;
+    private getAppData;
+    private getTaxConfig;
     getSummary(params: {
         products: any[];
         isPriceIncludeTax?: number;
         taxRate?: number;
+        shopDiscount?: string | number;
+        channel?: string;
     }): Promise<{
-        tax_title: any;
-        tax_rate: any;
+        tax_title: string;
+        tax_rate: number | undefined;
+        tax_country_code: string;
         product_quantity: number;
         product_original_amount: string;
         product_amount: string;
@@ -33,31 +49,12 @@ export declare class SalesSummaryModule extends BaseModule implements Module, Sa
         deposit?: import("./types").DepositInfo | undefined;
         expect_amount: string;
         total_amount: string;
+        total_refund_amount: string;
+        customer_paid_amount: string;
+        order_paid_amount: string;
         amount_gap: string;
         rounding_amount: string;
         pay_service_charge_amount: string;
         is_price_include_tax?: number | undefined;
-    } | {
-        tax_title: any;
-        tax_rate: any;
-        product_quantity: number;
-        product_original_amount: string;
-        product_amount: string;
-        product_expect_amount: string;
-        product_tax_fee: string;
-        shipping_fee: string;
-        shipping_tax_fee: string;
-        tax_fee: string;
-        surcharge_fee: string;
-        surcharges: any;
-        discount_amount: string;
-        deposit_amount: string;
-        deposit: import("./types").DepositInfo | undefined;
-        expect_amount: string;
-        total_amount: string;
-        amount_gap: string;
-        rounding_amount: string;
-        pay_service_charge_amount: string;
-        is_price_include_tax: number;
     }>;
 }