@pisell/pisellos 0.0.270 → 0.0.272

package/dist/solution/BookingByStep/utils/capacity.d.ts

@@ -45,3 +45,26 @@ export declare const checkSubResourcesCapacity: (resource: ResourceItem) => void
  * @returns 如果资源可以容纳额外的容量则返回 true
  */
 export declare const checkResourceCanUseByCapacity: (currentCapacity: number, requiredCapacity: number, maxCapacity: number) => boolean;
+/**
+ * 计算按资源类型分组的容量占用情况
+ *
+ * @param {CartItem[]} cartItems 购物车商品列表
+ * @param {string} timeSlotStart 时间段开始时间
+ * @param {string} timeSlotEnd 时间段结束时间
+ * @param {ResourceItem[]} allProductResources 当前商品的所有资源列表
+ * @return {Record<string, number>} 返回每种资源类型(form_id)的容量占用
+ */
+export declare function calculateCartItemsCapacityUsageByResourceType({ cartItems, timeSlotStart, timeSlotEnd, allProductResources }: {
+    cartItems: CartItem[];
+    timeSlotStart: string;
+    timeSlotEnd: string;
+    allProductResources: ResourceItem[];
+}): Record<string, number>;
+/**
+ * 获取商品的资源ID列表
+ */
+export declare function getResourcesIdsByProduct(product: any): number[];
+/**
+ * 检查特定时间段的容量是否足够
+ */
+export declare function checkTimeSlotCapacity(timeSlotStart: string, timeSlotEnd: string, cartItems: CartItem[], allResources: ResourceItem[]): boolean;

package/dist/solution/BookingByStep/utils/capacity.js

@@ -1,6 +1,16 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import dayjs from 'dayjs';
+
 /**
  * @title: 基于选择的商品格式化容量
  * @description:
@@ -129,4 +139,182 @@ export var checkResourceCanUseByCapacity = function checkResourceCanUseByCapacit
     return false;
   }
   return currentCapacity + requiredCapacity <= maxCapacity;
-};
+};
+
+/**
+ * 计算按资源类型分组的容量占用情况
+ * 
+ * @param {CartItem[]} cartItems 购物车商品列表
+ * @param {string} timeSlotStart 时间段开始时间
+ * @param {string} timeSlotEnd 时间段结束时间
+ * @param {ResourceItem[]} allProductResources 当前商品的所有资源列表
+ * @return {Record<string, number>} 返回每种资源类型(form_id)的容量占用
+ */
+export function calculateCartItemsCapacityUsageByResourceType(_ref3) {
+  var cartItems = _ref3.cartItems,
+    timeSlotStart = _ref3.timeSlotStart,
+    timeSlotEnd = _ref3.timeSlotEnd,
+    allProductResources = _ref3.allProductResources;
+  // 按 form_id 分组当前商品的资源
+  var resourceTypeMap = {};
+  allProductResources.forEach(function (resource) {
+    var _resource$form_id;
+    var formId = ((_resource$form_id = resource.form_id) === null || _resource$form_id === void 0 ? void 0 : _resource$form_id.toString()) || 'default';
+    if (!resourceTypeMap[formId]) {
+      resourceTypeMap[formId] = [];
+    }
+    resourceTypeMap[formId].push(resource);
+  });
+
+  // 计算每种资源类型的容量占用
+  var capacityUsageByType = {};
+  Object.keys(resourceTypeMap).forEach(function (formId) {
+    var totalUsage = 0;
+    var resourcesInThisType = resourceTypeMap[formId];
+    var resourceIdsInThisType = resourcesInThisType.map(function (r) {
+      return r.id;
+    });
+    cartItems.forEach(function (cartItem) {
+      // 检查该商品是否已经选定了时间
+      if (!cartItem.start_time || !cartItem.end_time) return;
+
+      // 构建该商品的时间段
+      var itemStart = "".concat(cartItem.start_date, " ").concat(cartItem.start_time);
+      var itemEnd = "".concat(cartItem.end_date || cartItem.start_date, " ").concat(cartItem.end_time);
+
+      // 检查时间段是否有重叠
+      var hasTimeOverlap = !(dayjs(itemEnd).isBefore(dayjs(timeSlotStart)) || dayjs(itemStart).isAfter(dayjs(timeSlotEnd)));
+      if (!hasTimeOverlap) return;
+
+      // 检查该商品的资源配置中是否需要这种类型的资源
+      // 由于购物车商品只选定了时间，没有选定具体资源，我们需要看商品的资源配置
+      var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+      var hasResourceTypeOverlap = productResourceIds.some(function (id) {
+        return resourceIdsInThisType.includes(id);
+      });
+      if (!hasResourceTypeOverlap) return;
+
+      // 计算该商品的容量占用
+      var _getCapacityInfoByCar = getCapacityInfoByCartItem(cartItem),
+        currentCapacity = _getCapacityInfoByCar.currentCapacity;
+      totalUsage += currentCapacity;
+    });
+    capacityUsageByType[formId] = totalUsage;
+  });
+  return capacityUsageByType;
+}
+
+/**
+ * 获取商品的资源ID列表
+ */
+export function getResourcesIdsByProduct(product) {
+  var _product$product_reso, _product$product_reso2;
+  var tempResourceIds = [];
+  product === null || product === void 0 || (_product$product_reso = product.product_resource) === null || _product$product_reso === void 0 || (_product$product_reso = _product$product_reso.resources) === null || _product$product_reso === void 0 || (_product$product_reso2 = _product$product_reso.forEach) === null || _product$product_reso2 === void 0 || _product$product_reso2.call(_product$product_reso, function (resource) {
+    if ((resource === null || resource === void 0 ? void 0 : resource.status) == 1) {
+      var _resource$default_res, _resource$optional_re;
+      if (resource !== null && resource !== void 0 && (_resource$default_res = resource.default_resource) !== null && _resource$default_res !== void 0 && _resource$default_res.length) {
+        tempResourceIds.push.apply(tempResourceIds, _toConsumableArray(resource === null || resource === void 0 ? void 0 : resource.default_resource));
+      } else if (resource !== null && resource !== void 0 && (_resource$optional_re = resource.optional_resource) !== null && _resource$optional_re !== void 0 && _resource$optional_re.length) {
+        tempResourceIds.push.apply(tempResourceIds, _toConsumableArray(resource === null || resource === void 0 ? void 0 : resource.optional_resource));
+      }
+    }
+  });
+  return tempResourceIds;
+}
+
+/**
+ * 检查特定时间段的容量是否足够
+ */
+export function checkTimeSlotCapacity(timeSlotStart, timeSlotEnd, cartItems, allResources) {
+  // 按资源类型分组
+  var resourceTypeMap = {};
+  allResources.forEach(function (resource) {
+    var _resource$form_id2;
+    var formId = ((_resource$form_id2 = resource.form_id) === null || _resource$form_id2 === void 0 ? void 0 : _resource$form_id2.toString()) || 'default';
+    if (!resourceTypeMap[formId]) {
+      resourceTypeMap[formId] = [];
+    }
+    resourceTypeMap[formId].push(resource);
+  });
+
+  // 计算每种资源类型需要的总容量
+  var requiredCapacityByType = {};
+  cartItems.forEach(function (cartItem) {
+    var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+    var _getCapacityInfoByCar2 = getCapacityInfoByCartItem(cartItem),
+      currentCapacity = _getCapacityInfoByCar2.currentCapacity;
+    Object.keys(resourceTypeMap).forEach(function (formId) {
+      var resourcesInType = resourceTypeMap[formId];
+      var resourceIdsInType = resourcesInType.map(function (r) {
+        return r.id;
+      });
+
+      // 检查该商品是否需要这种类型的资源
+      var needsThisResourceType = productResourceIds.some(function (id) {
+        return resourceIdsInType.includes(id);
+      });
+      if (needsThisResourceType) {
+        requiredCapacityByType[formId] = (requiredCapacityByType[formId] || 0) + currentCapacity;
+      }
+    });
+  });
+
+  // 检查每种资源类型是否有足够的容量
+  var _loop = function _loop() {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        formId = _Object$entries$_i[0],
+        requiredCapacity = _Object$entries$_i[1];
+      var resourcesInType = resourceTypeMap[formId];
+      if (resourcesInType.length === 0) return 0; // continue
+
+      // 确定这种资源类型的预约类型
+      var firstResource = resourcesInType[0];
+      var isMultipleBooking = firstResource.resourceType === 'multiple';
+      if (isMultipleBooking) {
+        // 多个预约：计算总可用容量
+        var totalAvailableCapacity = 0;
+        resourcesInType.forEach(function (resource) {
+          // 过滤出在时间段内的资源时间片
+          var availableTimes = resource.times.filter(function (time) {
+            return !dayjs(time.start_at).isAfter(dayjs(timeSlotStart), 'minute') && !dayjs(time.end_at).isBefore(dayjs(timeSlotEnd), 'minute') || dayjs(time.start_at).isBefore(dayjs(timeSlotEnd), 'minute') && dayjs(time.end_at).isAfter(dayjs(timeSlotStart), 'minute');
+          });
+          if (availableTimes.length > 0) {
+            // 简化逻辑：如果资源在时间段内有可用时间，就计算其容量
+            totalAvailableCapacity += resource.capacity || 0;
+          }
+        });
+        if (totalAvailableCapacity < requiredCapacity) {
+          console.log("\u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u5BB9\u91CF\u4E0D\u8DB3: \u9700\u8981 ").concat(requiredCapacity, ", \u53EF\u7528 ").concat(totalAvailableCapacity));
+          return {
+            v: false
+          };
+        }
+      } else {
+        // 单个预约：计算可用资源数量
+        var availableResourceCount = 0;
+        resourcesInType.forEach(function (resource) {
+          // 过滤出在时间段内的资源时间片
+          var availableTimes = resource.times.filter(function (time) {
+            return !dayjs(time.start_at).isAfter(dayjs(timeSlotStart), 'minute') && !dayjs(time.end_at).isBefore(dayjs(timeSlotEnd), 'minute') || dayjs(time.start_at).isBefore(dayjs(timeSlotEnd), 'minute') && dayjs(time.end_at).isAfter(dayjs(timeSlotStart), 'minute');
+          });
+          if (availableTimes.length > 0) {
+            availableResourceCount++;
+          }
+        });
+        if (availableResourceCount < requiredCapacity) {
+          console.log("\u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u6570\u91CF\u4E0D\u8DB3: \u9700\u8981 ").concat(requiredCapacity, ", \u53EF\u7528 ").concat(availableResourceCount));
+          return {
+            v: false
+          };
+        }
+      }
+    },
+    _ret;
+  for (var _i = 0, _Object$entries = Object.entries(requiredCapacityByType); _i < _Object$entries.length; _i++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return true;
+}

package/dist/solution/BookingByStep/utils/stock.d.ts

@@ -0,0 +1,29 @@
+import { CartItem } from '../../../modules';
+/**
+ * 检测商品库存是否足够
+ *
+ * 只有同时满足以下条件时才会进行库存检测：
+ * - is_track 开启（值为 1 或 true）
+ * - over_sold 为 0（不允许超卖）
+ *
+ * 对于多规格商品：
+ * - 如果有 product_variant_id，则从 productData.variant 数组中查找对应规格
+ * - 使用规格的 is_track, over_sold, stock_quantity 而不是主商品的
+ *
+ * @param productData 商品数据（需包含 is_track, over_sold, stock_quantity 字段，多规格商品需包含 variant 数组）
+ * @param product_variant_id 商品变体ID，如果存在则为多规格商品
+ * @param quantity 需要添加的数量
+ * @param bundle 套餐配置（子商品需包含 is_track, over_sold, stock_quantity 字段）
+ * @param currentCartItems 当前购物车商品列表
+ * @returns 库存检测结果
+ */
+export declare function checkProductStock({ productData, product_variant_id, quantity, bundle, currentCartItems }: {
+    productData: any;
+    product_variant_id?: any;
+    quantity: number;
+    bundle?: any[];
+    currentCartItems: CartItem[];
+}): {
+    success: boolean;
+    errorCode?: string;
+};

package/dist/solution/BookingByStep/utils/stock.js

@@ -0,0 +1,126 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * 检测商品库存是否足够
+ * 
+ * 只有同时满足以下条件时才会进行库存检测：
+ * - is_track 开启（值为 1 或 true）
+ * - over_sold 为 0（不允许超卖）
+ * 
+ * 对于多规格商品：
+ * - 如果有 product_variant_id，则从 productData.variant 数组中查找对应规格
+ * - 使用规格的 is_track, over_sold, stock_quantity 而不是主商品的
+ * 
+ * @param productData 商品数据（需包含 is_track, over_sold, stock_quantity 字段，多规格商品需包含 variant 数组）
+ * @param product_variant_id 商品变体ID，如果存在则为多规格商品
+ * @param quantity 需要添加的数量
+ * @param bundle 套餐配置（子商品需包含 is_track, over_sold, stock_quantity 字段）
+ * @param currentCartItems 当前购物车商品列表
+ * @returns 库存检测结果
+ */
+export function checkProductStock(_ref) {
+  var productData = _ref.productData,
+    product_variant_id = _ref.product_variant_id,
+    quantity = _ref.quantity,
+    bundle = _ref.bundle,
+    currentCartItems = _ref.currentCartItems;
+  // 1. 检测主商品库存
+  // 处理多规格商品：如果有product_variant_id，则从variant数组中查找对应的规格配置
+  var mainProductConfig = productData;
+  if (product_variant_id && productData.variant && Array.isArray(productData.variant)) {
+    var variant = productData.variant.find(function (v) {
+      return v.id === product_variant_id;
+    });
+    if (variant) {
+      mainProductConfig = variant; // 使用规格的配置替换主商品配置
+    }
+  }
+
+  // 只有开启库存控制且不允许超卖时才需要检测主商品库存
+  var isMainProductTrackingEnabled = mainProductConfig.is_track === 1 || mainProductConfig.is_track === true;
+  var isMainProductOverSoldDisabled = mainProductConfig.over_sold === 0;
+  if (isMainProductTrackingEnabled && isMainProductOverSoldDisabled) {
+    var existingQuantity = currentCartItems.reduce(function (total, cartItem) {
+      var _cartItem$_productOri, _cartItem$_productOri2, _cartItem$_productOri3;
+      // 检查是否为相同商品（比较商品ID和变体ID）
+      var isSameProduct = ((_cartItem$_productOri = cartItem._productOrigin) === null || _cartItem$_productOri === void 0 ? void 0 : _cartItem$_productOri.id) === productData.id;
+      var isSameVariant = !product_variant_id && !((_cartItem$_productOri2 = cartItem._productOrigin) !== null && _cartItem$_productOri2 !== void 0 && _cartItem$_productOri2.product_variant_id) || ((_cartItem$_productOri3 = cartItem._productOrigin) === null || _cartItem$_productOri3 === void 0 ? void 0 : _cartItem$_productOri3.product_variant_id) === product_variant_id;
+      if (isSameProduct && isSameVariant) {
+        return total + (cartItem.num || 0);
+      }
+      return total;
+    }, 0);
+    var totalQuantity = existingQuantity + quantity;
+    var stockQuantity = mainProductConfig.stock_quantity;
+
+    // 检查主商品库存是否足够
+    if (stockQuantity !== undefined && stockQuantity !== null && totalQuantity > stockQuantity) {
+      return {
+        success: false,
+        errorCode: 'not_enough_stock'
+      };
+    }
+  }
+
+  // 2. 检测套餐商品库存
+  if (bundle && Array.isArray(bundle)) {
+    // 直接遍历套餐商品数组
+    var _iterator = _createForOfIteratorHelper(bundle),
+      _step;
+    try {
+      var _loop = function _loop() {
+          var bundleItem = _step.value;
+          var bundleProductId = bundleItem.bundle_product_id;
+          var bundleStockQuantity = bundleItem.stock_quantity;
+          var bundleRequiredQuantity = (bundleItem.num || 1) * quantity; // 子商品需求数量 = 子商品配置数量 * 主商品购买数量
+
+          // 检查套餐子商品是否需要进行库存控制
+          var isBundleTrackingEnabled = bundleItem.is_track === 1 || bundleItem.is_track === true;
+          var isBundleOverSoldDisabled = bundleItem.over_sold === 0;
+
+          // 跳过没有开启库存控制或允许超卖的子商品
+          if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled) return 0; // continue
+
+          // 跳过没有库存配置的子商品
+          if (bundleStockQuantity === undefined || bundleStockQuantity === null) return 0; // continue
+
+          // 计算购物车中已有的相同子商品数量
+          var existingBundleQuantity = currentCartItems.reduce(function (total, cartItem) {
+            // 检查购物车中商品的套餐配置
+            if (!cartItem._bundleOrigin || !Array.isArray(cartItem._bundleOrigin)) return total;
+            cartItem._bundleOrigin.forEach(function (cartBundleItem) {
+              if (cartBundleItem.bundle_product_id === bundleProductId) {
+                total += (cartBundleItem.num || 1) * (cartItem.num || 1);
+              }
+            });
+            return total;
+          }, 0);
+          var totalBundleQuantity = existingBundleQuantity + bundleRequiredQuantity;
+
+          // 检查子商品库存是否足够
+          if (totalBundleQuantity > bundleStockQuantity) {
+            return {
+              v: {
+                success: false,
+                errorCode: 'not_enough_stock'
+              }
+            };
+          }
+        },
+        _ret;
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _ret = _loop();
+        if (_ret === 0) continue;
+        if (_ret) return _ret.v;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return {
+    success: true
+  };
+}

package/dist/solution/Checkout/index.js

@@ -1284,7 +1284,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
     value: (function () {
       var _updateVoucherPaymentItemsAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17(voucherPaymentItems) {
         var _this3 = this;
-        var orderPaymentType, voucherPaymentItemsWithType, currentOrderId, isCurrentOrderReal, updatedOrder;
+        var remainingAmount, remainingValue, isOrderSynced, orderPaymentType, voucherPaymentItemsWithType, currentOrderId, isCurrentOrderReal, updatedOrder;
         return _regeneratorRuntime().wrap(function _callee17$(_context17) {
           while (1) switch (_context17.prev = _context17.next) {
             case 0:
@@ -1295,6 +1295,26 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
               throw createCheckoutError(CheckoutErrorType.ValidationFailed, '当前没有活跃订单，无法更新代金券支付项');
             case 3:
+              _context17.next = 5;
+              return this.calculateRemainingAmountAsync();
+            case 5:
+              remainingAmount = _context17.sent;
+              remainingValue = new Decimal(remainingAmount);
+              isOrderSynced = this.store.isOrderSynced;
+              if (!(remainingValue.lte(0) && isOrderSynced && voucherPaymentItems.length === 0)) {
+                _context17.next = 11;
+                break;
+              }
+              this.logInfo('订单已同步且支付完成，跳过清空代金券操作避免重复同步:', {
+                orderUuid: this.store.currentOrder.uuid,
+                orderId: this.store.currentOrder.order_id,
+                remainingAmount: remainingAmount,
+                isOrderSynced: isOrderSynced,
+                voucherPaymentItemsCount: voucherPaymentItems.length,
+                reason: 'Order synced and payment completed, skip clear vouchers to avoid duplicate sync'
+              });
+              return _context17.abrupt("return");
+            case 11:
               this.logInfo('开始批量更新代金券支付项:', {
                 voucherPaymentItems: voucherPaymentItems
               });
@@ -1316,15 +1336,15 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   metadata: metadata
                 });
               }); // 调用 Payment 模块的批量更新方法
-              _context17.next = 8;
+              _context17.next = 16;
               return this.payment.updateVoucherPaymentItemsAsync(this.store.currentOrder.uuid, voucherPaymentItemsWithType);
-            case 8:
+            case 16:
               // 重新从Payment模块获取最新的订单数据，确保支付项同步
               currentOrderId = this.store.currentOrder.order_id; // 保存当前的订单ID
               isCurrentOrderReal = currentOrderId && !isVirtualOrderId(currentOrderId);
-              _context17.next = 12;
+              _context17.next = 20;
               return this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-            case 12:
+            case 20:
               updatedOrder = _context17.sent;
               if (updatedOrder) {
                 // 如果当前订单ID是真实ID，但获取到的订单ID是虚拟ID，需要保护真实ID
@@ -1339,10 +1359,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
 
               // 更新 stateAmount 为剩余未支付金额
-              _context17.next = 16;
+              _context17.next = 24;
               return this.updateStateAmountToRemaining();
-            case 16:
-              _context17.next = 18;
+            case 24:
+              _context17.next = 26;
               return this.core.effects.emit(CheckoutHooks.OnPaymentStarted, {
                 orderUuid: this.store.currentOrder.uuid,
                 paymentMethodCode: 'VOUCHER_BATCH',
@@ -1351,23 +1371,23 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 }, 0).toFixed(2),
                 timestamp: Date.now()
               });
-            case 18:
+            case 26:
               this.logInfo('代金券支付项批量更新成功');
-              _context17.next = 27;
+              _context17.next = 35;
               break;
-            case 21:
-              _context17.prev = 21;
+            case 29:
+              _context17.prev = 29;
               _context17.t0 = _context17["catch"](0);
               this.logError('[Checkout] 批量更新代金券支付项失败:', _context17.t0);
-              _context17.next = 26;
+              _context17.next = 34;
               return this.handleError(_context17.t0, CheckoutErrorType.PaymentFailed);
-            case 26:
+            case 34:
               throw _context17.t0;
-            case 27:
+            case 35:
             case "end":
               return _context17.stop();
           }
-        }, _callee17, this, [[0, 21]]);
+        }, _callee17, this, [[0, 29]]);
       }));
       function updateVoucherPaymentItemsAsync(_x16) {
         return _updateVoucherPaymentItemsAsync.apply(this, arguments);

package/lib/modules/Payment/index.js

@@ -670,36 +670,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       if (!order) {
         throw new Error(`订单不存在: ${orderUuid}`);
       }
-      const expectAmount = new import_decimal.Decimal(order.expect_amount);
-      if (expectAmount.lte(0) && voucherPaymentItems.length === 0) {
-        console.warn("[PaymentModule] Skipping voucher update - order already fully paid:", {
-          orderUuid,
-          expectAmount: order.expect_amount,
-          attemptedOperation: "clear_vouchers",
-          reason: "Order payment completed, no need to clear vouchers"
-        });
-        this.logInfo("updateVoucherPaymentItemsAsync skipped - order already paid", {
-          orderUuid,
-          expectAmount: order.expect_amount,
-          voucherCount: voucherPaymentItems.length
-        });
-        return;
-      }
-      if (expectAmount.lte(0) && voucherPaymentItems.length > 0) {
-        const warningMessage = `订单 ${orderUuid} 已完成支付，不允许添加代金券支付项`;
-        console.warn("[PaymentModule] Voucher update blocked - order already fully paid:", {
-          orderUuid,
-          expectAmount: order.expect_amount,
-          attemptedVoucherCount: voucherPaymentItems.length,
-          reason: "Order already fully paid"
-        });
-        this.logError("updateVoucherPaymentItemsAsync blocked", new Error(warningMessage), {
-          orderUuid,
-          expectAmount: order.expect_amount,
-          voucherPaymentItems
-        });
-        throw new Error(warningMessage);
-      }
       const existingVoucherItems = order.payment.filter(
         (payment) => payment.voucher_id && payment.status !== "voided"
       );

package/lib/modules/Rules/index.js

@@ -212,6 +212,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             tag: discountType,
             discount: {
               discount_card_type: (_d = discount == null ? void 0 : discount.metadata) == null ? void 0 : _d.discount_card_type,
+              fixed_amount: product.price,
               resource_id: discount.id,
               title: discount.format_title,
               original_amount: product.origin_total,
@@ -346,6 +347,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
           type: discountType,
           discount: {
             discount_card_type: (_j = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _j.discount_card_type,
+            fixed_amount: new import_decimal.default(productOriginTotal).minus(new import_decimal.default(targetProductTotal)).toNumber(),
             resource_id: selectedDiscount2.id,
             title: selectedDiscount2.format_title,
             original_amount: productOriginTotal,

package/lib/solution/BookingByStep/index.d.ts

@@ -180,7 +180,10 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
      * @param {ProductData} productData
      * @memberof BookingByStepImpl
      */
-    storeProduct(productData: ProductData): Promise<void>;
+    storeProduct(productData: ProductData): {
+        success: boolean;
+        errorCode?: string;
+    };
     /**
      * 往购物车加商品数据
      *
@@ -203,7 +206,10 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
             endTime: string;
         } | null;
         account?: Account | null;
-    }): void;
+    }): {
+        success: boolean;
+        errorCode?: string;
+    };
     /**
      * 添加完购物车以后做的一些检测，比如日期是否在同一天
      *
@@ -294,8 +300,6 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
     };
     getTimeSlotByAllResources(resources_code: string): any[];
     submitTimeSlot(timeSlots: TimeSliceItem): void;
-    clearCache(): void;
-    clearCacheByModule(module: string): void;
     private getScheduleDataByIds;
     openProductDetail(productId: number): Promise<void>;
     closeProductDetail(): void;
@@ -312,6 +316,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         count: number;
         left: number;
     }[];
+    checkMaxDurationCapacity(): boolean;
     setOtherData(key: string, value: any): void;
     getOtherData(key: string): any;
     getProductTypeById(id: number): Promise<"normal" | "duration" | "session">;