@pisell/pisellos 3.0.65 → 3.0.66

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,223 @@ 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 _cartItem$_productOri;
+      var resourcesInType = resourceTypeMap[formId];
+      var resourceIdsInType = resourcesInType.map(function (r) {
+        return r.id;
+      });
+      var selectType = (_cartItem$_productOri = cartItem._productOrigin) === null || _cartItem$_productOri === void 0 || (_cartItem$_productOri = _cartItem$_productOri.product_resource) === null || _cartItem$_productOri === void 0 || (_cartItem$_productOri = _cartItem$_productOri.resources) === null || _cartItem$_productOri === void 0 || (_cartItem$_productOri = _cartItem$_productOri.find(function (r) {
+        var _r$id;
+        return ((_r$id = r.id) === null || _r$id === void 0 ? void 0 : _r$id.toString()) === formId;
+      })) === null || _cartItem$_productOri === void 0 ? void 0 : _cartItem$_productOri.type;
+
+      // 检查该商品是否需要这种类型的资源
+      var needsThisResourceType = productResourceIds.some(function (id) {
+        return resourceIdsInType.includes(id);
+      });
+      if (needsThisResourceType) {
+        // 需要判断是单个预约还是多个预约，如果是单个预约，不用加 capacity，只用+1
+        if (selectType === 'single') {
+          requiredCapacityByType[formId] = (requiredCapacityByType[formId] || 0) + 1;
+        } else {
+          requiredCapacityByType[formId] = (requiredCapacityByType[formId] || 0) + currentCapacity;
+        }
+        // requiredCapacityByType[formId] = (requiredCapacityByType[formId] || 0) + currentCapacity;
+      }
+    });
+  });
+
+  // 检查每种资源类型是否有足够的容量
+  var _loop = function _loop() {
+      var _resourceTypeConfig, _resourceTypeConfig2;
+      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 resourceTypeConfig = null;
+      var _iterator2 = _createForOfIteratorHelper(cartItems),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _cartItem$_productOri2;
+          var cartItem = _step2.value;
+          if ((_cartItem$_productOri2 = cartItem._productOrigin) !== null && _cartItem$_productOri2 !== void 0 && (_cartItem$_productOri2 = _cartItem$_productOri2.product_resource) !== null && _cartItem$_productOri2 !== void 0 && _cartItem$_productOri2.resources) {
+            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(function (r) {
+              var _r$id2;
+              return ((_r$id2 = r.id) === null || _r$id2 === void 0 ? void 0 : _r$id2.toString()) === formId && r.status === 1;
+            });
+            if (resourceTypeConfig) break;
+          }
+        }
+
+        // 确定这种资源类型的预约类型
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var isMultipleBooking = ((_resourceTypeConfig = resourceTypeConfig) === null || _resourceTypeConfig === void 0 ? void 0 : _resourceTypeConfig.type) === 'multiple';
+      console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u914D\u7F6E:"), {
+        resourceTypeConfig: resourceTypeConfig,
+        type: (_resourceTypeConfig2 = resourceTypeConfig) === null || _resourceTypeConfig2 === void 0 ? void 0 : _resourceTypeConfig2.type,
+        isMultipleBooking: isMultipleBooking,
+        requiredCapacity: requiredCapacity
+      });
+      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;
+          }
+        });
+        console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u591A\u4E2A\u9884\u7EA6\u68C0\u67E5: \u603B\u5BB9\u91CF ").concat(totalAvailableCapacity, ", \u9700\u6C42 ").concat(requiredCapacity));
+        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++;
+          }
+        });
+        console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u5355\u4E2A\u9884\u7EA6\u68C0\u67E5: \u53EF\u7528\u8D44\u6E90\u6570 ").concat(availableResourceCount, ", \u9700\u6C42 ").concat(requiredCapacity));
+        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/resources.d.ts

@@ -20,6 +20,21 @@ export interface ResourceItem {
 interface BookingItem {
     [key: string]: any;
 }
+/**
+ * @title: 判断两个时间段是否有重叠
+ * @description:
+ * @param {object} event
+ * @param {object} current
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const isConflict: (event: {
+    start_at: DateType;
+    end_at: DateType;
+}, current: {
+    start_at: DateType;
+    end_at?: DateType;
+}) => boolean;
 /**
  * @title: 获取时间切片是否可用
  * @description: 根据时间切片、资源、当前预约量判断时间切片是否可用

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

@@ -42,7 +42,7 @@ var getUseableEventCount = function getUseableEventCount(eventList, current) {
  * @return {*}
  * @Author: zhiwei.Wang
  */
-var isConflict = function isConflict(event, current) {
+export var isConflict = function isConflict(event, current) {
   var eventStart = dayjs(event.start_at);
   var eventEnd = dayjs(event.end_at);
   var currentStart = dayjs(current.start_at);

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/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,14 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         count: number;
         left: number;
     }[];
+    /**
+     * 找到多个资源的公共可用时间段
+     */
+    private findCommonAvailableTimeSlots;
+    checkMaxDurationCapacity(): {
+        success: boolean;
+        minAvailableCount: number;
+    };
     setOtherData(key: string, value: any): void;
     getOtherData(key: string): any;
     getProductTypeById(id: number): Promise<"duration" | "session" | "normal">;