@pisell/pisellos 3.0.32 → 3.0.34

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

@@ -782,4 +782,103 @@ export var checkSubResourcesCapacity = function checkSubResourcesCapacity(resour
       }
     });
   }
-};
+};
+
+/**
+ * @title: 根据日期范围过滤日程
+ *
+ * @export
+ * @param {any[]} schedule
+ * @param {string} startDate
+ * @param {string} endDate
+ * @return {*}
+ */
+export function filterScheduleByDateRange(schedule, startDate, endDate) {
+  if (!(schedule !== null && schedule !== void 0 && schedule.length)) return [];
+  var start = new Date(startDate);
+  var end = new Date(endDate);
+  return schedule.filter(function (item) {
+    var itemDate = new Date(item.date);
+    return itemDate >= start && itemDate <= end;
+  });
+}
+
+/**
+ * 传入商品数据，返回基于商品配置的提前量的最早开始日期和最晚结束日期
+ *
+ * @export
+ * @param {ProductData} product
+ * @return {*}
+ */
+export function checkSessionProductLeadTime(product) {
+  var latestStartDate = ''; // 最晚开始日期
+  var earliestEndDate = ''; // 最早结束日期
+  var _product$cut_off_time = product.cut_off_time,
+    future_day = _product$cut_off_time.future_day,
+    unit = _product$cut_off_time.unit,
+    unit_type = _product$cut_off_time.unit_type;
+  // 预定天数存在，则开始计算从当前时间开始往后推预定天数作为结束时间
+  if (future_day) {
+    var endDate = dayjs().add(future_day, 'day');
+    if (!earliestEndDate || endDate.isBefore(dayjs(earliestEndDate), 'day')) {
+      earliestEndDate = endDate.format('YYYY-MM-DD');
+    }
+  } else if (future_day === 0) {
+    var _endDate = dayjs();
+    if (!earliestEndDate || _endDate.isBefore(dayjs(earliestEndDate), 'day')) {
+      earliestEndDate = _endDate.format('YYYY-MM-DD');
+    }
+  }
+  // 如果存在提前预约时间，则开始计算从当前时间开始往后推提前预约时间作为开始时间
+  if (unit && unit_type) {
+    var startDate = dayjs(dayjs().add(unit, unit_type).format('YYYY-MM-DD'));
+    if (!latestStartDate || startDate.isAfter(dayjs(latestStartDate), 'day')) {
+      latestStartDate = startDate.format('YYYY-MM-DD');
+    }
+  }
+  return {
+    latestStartDate: latestStartDate,
+    earliestEndDate: earliestEndDate
+  };
+}
+
+/**
+ * 基于商品的 resources 配置，返回可选择的资源的 id 列表
+ *
+ * @export
+ * @param {ProductData} product
+ * @return {*}
+ */
+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
+ * @param {ResourceItem[]} resourcesList
+ * @return {*}
+ */
+export function sortCombinedResources(resourcesList) {
+  var newResourcesList = _toConsumableArray(resourcesList);
+  newResourcesList.sort(function (a, b) {
+    var _a$metadata2, _b$metadata2;
+    var aIsCombined = ((_a$metadata2 = a.metadata) === null || _a$metadata2 === void 0 || (_a$metadata2 = _a$metadata2.combined_resource) === null || _a$metadata2 === void 0 ? void 0 : _a$metadata2.status) === 1;
+    var bIsCombined = ((_b$metadata2 = b.metadata) === null || _b$metadata2 === void 0 || (_b$metadata2 = _b$metadata2.combined_resource) === null || _b$metadata2 === void 0 ? void 0 : _b$metadata2.status) === 1;
+    return aIsCombined === bIsCombined ? 0 : aIsCombined ? 1 : -1;
+  });
+  return newResourcesList;
+}

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

@@ -0,0 +1,25 @@
+import { ResourceItem, TimeSliceItem } from "./resources";
+/**
+ * 计算资源在指定时间段内的总可用时间（以分钟为单位）
+ * @param resource 需要计算可用时间的资源
+ * @param timeSlots 要检查可用性的时间段
+ * @param currentCapacity 当前预约所需的容量
+ * @returns 总可用时间（分钟）
+ */
+export declare function calculateResourceAvailableTime({ resource, timeSlots, currentCapacity, }: {
+    resource: ResourceItem;
+    timeSlots: TimeSliceItem;
+    currentCapacity?: number;
+}): number;
+/**
+ * 查找最快可用的资源，如果有多个资源在相同时间点可用，则选择空闲时间最长的资源
+ * @param resources 资源列表
+ * @param currentCapacity 当前预约所需的容量
+ * @param countMap 已预约数量映射
+ * @returns 最快可用的资源
+ */
+export declare function findFastestAvailableResource({ resources, currentCapacity, countMap, }: {
+    resources: ResourceItem[];
+    currentCapacity?: number;
+    countMap?: Record<number, number>;
+}): ResourceItem | null;

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

@@ -0,0 +1,209 @@
+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";
+/**
+ * 计算资源在指定时间段内的总可用时间（以分钟为单位）
+ * @param resource 需要计算可用时间的资源
+ * @param timeSlots 要检查可用性的时间段
+ * @param currentCapacity 当前预约所需的容量
+ * @returns 总可用时间（分钟）
+ */
+export function calculateResourceAvailableTime(_ref) {
+  var resource = _ref.resource,
+    timeSlots = _ref.timeSlots,
+    _ref$currentCapacity = _ref.currentCapacity,
+    currentCapacity = _ref$currentCapacity === void 0 ? 1 : _ref$currentCapacity;
+  // 过滤出与给定日期相同的资源时间
+  var matchingTimes = resource.times.filter(function (time) {
+    return dayjs(time.start_at).isSame(dayjs(timeSlots.start_at), 'day');
+  });
+  if (matchingTimes.length === 0) return 0;
+
+  // 计算所有时间段与目标时间槽的重叠部分
+  var overlaps = [];
+  var _iterator = _createForOfIteratorHelper(matchingTimes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var time = _step.value;
+      // 计算实际重叠的时间段
+      var overlapStart = dayjs(time.start_at).isAfter(dayjs(timeSlots.start_at)) ? dayjs(time.start_at) : dayjs(timeSlots.start_at);
+      var overlapEnd = dayjs(time.end_at).isBefore(dayjs(timeSlots.end_at)) ? dayjs(time.end_at) : dayjs(timeSlots.end_at);
+
+      // 只有当重叠时间段有效时才添加
+      if (overlapStart.isBefore(overlapEnd)) {
+        overlaps.push({
+          start: overlapStart,
+          end: overlapEnd
+        });
+      }
+    }
+
+    // 合并重叠的时间段，计算并集
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (overlaps.length === 0) return 0;
+
+  // 按开始时间排序
+  overlaps.sort(function (a, b) {
+    return a.start.diff(b.start);
+  });
+
+  // 合并重叠的时间段
+  var merged = [];
+  var current = overlaps[0];
+  for (var i = 1; i < overlaps.length; i++) {
+    var next = overlaps[i];
+
+    // 如果当前时间段与下一个时间段重叠或相邻，则合并
+    if (current.end.isSameOrAfter(next.start)) {
+      current.end = current.end.isAfter(next.end) ? current.end : next.end;
+    } else {
+      // 不重叠，添加当前时间段到结果中，开始处理下一个
+      merged.push(current);
+      current = next;
+    }
+  }
+  merged.push(current);
+
+  // 计算所有合并后时间段的总时长
+  var totalAvailableMinutes = 0;
+  for (var _i = 0, _merged = merged; _i < _merged.length; _i++) {
+    var segment = _merged[_i];
+    totalAvailableMinutes += segment.end.diff(segment.start, 'minute');
+  }
+  return totalAvailableMinutes;
+}
+
+/**
+ * 查找最快可用的资源，如果有多个资源在相同时间点可用，则选择空闲时间最长的资源
+ * @param resources 资源列表
+ * @param currentCapacity 当前预约所需的容量
+ * @param countMap 已预约数量映射
+ * @returns 最快可用的资源
+ */
+export function findFastestAvailableResource(_ref2) {
+  var resources = _ref2.resources,
+    _ref2$currentCapacity = _ref2.currentCapacity,
+    currentCapacity = _ref2$currentCapacity === void 0 ? 1 : _ref2$currentCapacity,
+    _ref2$countMap = _ref2.countMap,
+    countMap = _ref2$countMap === void 0 ? {} : _ref2$countMap;
+  var currentTime = dayjs();
+  var fastestTime = null;
+  var fastestResources = [];
+
+  // 遍历所有资源，找到最快可用的时间点
+  var _iterator2 = _createForOfIteratorHelper(resources),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _resource = _step2.value;
+      // 获取资源当天的时间段
+      var todayTimes = _resource.times.filter(function (time) {
+        return dayjs(time.start_at).isSame(currentTime, 'day');
+      });
+      if (todayTimes.length === 0) continue;
+
+      // 按开始时间排序
+      todayTimes.sort(function (a, b) {
+        return dayjs(a.start_at).diff(dayjs(b.start_at));
+      });
+
+      // 找到第一个可用的时间段
+      var _iterator3 = _createForOfIteratorHelper(todayTimes),
+        _step3;
+      try {
+        var _loop = function _loop() {
+            var time = _step3.value;
+            var startTime = dayjs(time.start_at);
+
+            // 如果开始时间在当前时间之前，跳过
+            if (startTime.isBefore(currentTime)) return 0; // continue
+
+            // 检查这个时间段是否可用
+            if (_resource.resourceType === 'single') {
+              var _time$event_list;
+              // 单个预约类型：检查是否有预约
+              var hasBooking = (_time$event_list = time.event_list) === null || _time$event_list === void 0 ? void 0 : _time$event_list.some(function (event) {
+                return dayjs(event.start_at).isSame(startTime);
+              });
+              if (!hasBooking) {
+                if (!fastestTime || startTime.isSame(fastestTime)) {
+                  fastestTime = startTime;
+                  fastestResources.push(_resource);
+                } else if (startTime.isBefore(fastestTime)) {
+                  fastestTime = startTime;
+                  fastestResources = [_resource];
+                }
+                return 1; // break
+              }
+            } else {
+              var _time$event_list2;
+              // 多个预约类型：检查容量
+              var totalCapacity = _resource.capacity || 0;
+              var usedCapacity = ((_time$event_list2 = time.event_list) === null || _time$event_list2 === void 0 ? void 0 : _time$event_list2.reduce(function (sum, event) {
+                return dayjs(event.start_at).isSame(startTime) ? sum + (event.pax || 0) : sum;
+              }, 0)) || 0;
+              var remainingCapacity = totalCapacity - usedCapacity;
+              if (remainingCapacity >= (countMap[_resource.id] || 0) + currentCapacity) {
+                if (!fastestTime || startTime.isSame(fastestTime)) {
+                  fastestTime = startTime;
+                  fastestResources.push(_resource);
+                } else if (startTime.isBefore(fastestTime)) {
+                  fastestTime = startTime;
+                  fastestResources = [_resource];
+                }
+                return 1; // break
+              }
+            }
+          },
+          _ret;
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          _ret = _loop();
+          if (_ret === 0) continue;
+          if (_ret === 1) break;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+
+    // 如果没有找到可用资源，返回null
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (!fastestTime || fastestResources.length === 0) return null;
+
+  // 如果只有一个最快可用的资源，直接返回
+  if (fastestResources.length === 1) return fastestResources[0];
+
+  // 如果有多个最快可用的资源，比较它们的空闲时间
+  var maxIdleTime = 0;
+  var selectedResource = null;
+  for (var _i2 = 0, _fastestResources = fastestResources; _i2 < _fastestResources.length; _i2++) {
+    var resource = _fastestResources[_i2];
+    var idleTime = calculateResourceAvailableTime({
+      resource: resource,
+      timeSlots: {
+        start_time: fastestTime.format('HH:mm'),
+        end_time: fastestTime.format('HH:mm'),
+        start_at: fastestTime,
+        end_at: fastestTime
+      },
+      currentCapacity: (countMap[resource.id] || 0) + currentCapacity
+    });
+    if (idleTime > maxIdleTime) {
+      maxIdleTime = idleTime;
+      selectedResource = resource;
+    }
+  }
+  return selectedResource;
+}

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

@@ -15,6 +15,8 @@ export declare class DateModule extends BaseModule implements Module, DateModule
     getDateRange(): ITime[];
     getResourceDates(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     getDateList(): ITime[];
+    setDateList(dateList: ITime[]): void;
+    fetchResourceDates(params: IGetAvailableTimeListParams): Promise<any>;
     getResourceAvailableTimeList(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     clearDateRange(): void;
     storeChange(): void;

package/lib/modules/Date/index.js

@@ -65,18 +65,13 @@ var DateModule = class extends import_BaseModule.BaseModule {
   getDateList() {
     return this.store.dateList;
   }
-  async getResourceAvailableTimeList(params) {
-    var _a;
-    const { url, query, rules, type } = params;
+  setDateList(dateList) {
+    this.store.dateList = dateList;
+  }
+  async fetchResourceDates(params) {
+    const { url, query } = params;
     const fetchUrl = url || "/schedule/resource/list";
     const { start_date, end_date, resource_ids } = query || {};
-    if (!start_date || !end_date) {
-      return [];
-    }
-    let dates = (0, import_utils.generateMonthDates)(start_date, end_date, type);
-    if (!(resource_ids == null ? void 0 : resource_ids.length)) {
-      return (0, import_utils.disableAllDates)(dates);
-    }
     try {
       const res = await this.request.get(fetchUrl, {
         start_date,
@@ -86,6 +81,24 @@ var DateModule = class extends import_BaseModule.BaseModule {
       }, {
         useCache: true
       });
+      return res;
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  async getResourceAvailableTimeList(params) {
+    var _a;
+    const { query, rules, type } = params;
+    const { start_date, end_date, resource_ids } = query || {};
+    if (!start_date || !end_date) {
+      return [];
+    }
+    let dates = (0, import_utils.generateMonthDates)(start_date, end_date, type);
+    if (!(resource_ids == null ? void 0 : resource_ids.length)) {
+      return (0, import_utils.disableAllDates)(dates);
+    }
+    try {
+      const res = await this.fetchResourceDates(params);
       if (!((_a = res == null ? void 0 : res.data) == null ? void 0 : _a.length)) {
         return (0, import_utils.disableAllDates)(dates);
       }

package/lib/modules/Rules/index.js

@@ -58,10 +58,10 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         productList
       };
     }
-    const mergedDiscountList = (0, import_utils.uniqueById)([
+    const mergedDiscountList = (0, import_utils.uniqueById)((0, import_utils.uniqueById)([
       ...oldDiscountList,
       ...newDiscountList
-    ]);
+    ]), "product_id");
     const result = this.calcDiscount({
       discountList: mergedDiscountList,
       productList: [...productList]

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

@@ -6,6 +6,7 @@ export interface ScheduleState {
 export type ScheduleAvailabilityDateItem = {
     date: string;
     schedule_id: number[];
+    product_ids: number[];
 };
 export interface ScheduleModuleAPI {
 }

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

@@ -5,7 +5,7 @@ import { BookingByStepState } from './types';
 import { CartItem, IUpdateItemParams, ProductData, ProductResourceItem, ECartItemInfoType, ECartItemCheckType } from '../../modules';
 import { Account } from '../../modules/Account/types';
 import { IStep } from '../../modules/Step/tyeps';
-import { TimeSliceItem } from './utils/resources';
+import { TimeSliceItem, ResourceItem } from './utils/resources';
 import { ITime } from '../../modules/Date/types';
 import dayjs from 'dayjs';
 import { IHolder, IFetchHolderAccountsParams } from '../../modules/AccountList/types';
@@ -153,7 +153,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         id: number | undefined;
         _id: string;
         product: ProductData | undefined;
-        resources: import("./utils/resources").ResourceItem[];
+        resources: ResourceItem[];
         holder_id: string | number | undefined;
         holder_name: string | undefined;
     } | undefined;
@@ -189,7 +189,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
     private getScheduleDataByIds;
     openProductDetail(productId: number): Promise<void>;
     closeProductDetail(): void;
-    getTimeslotBySchedule({ date, scheduleIds, resources, product }: {
+    getTimeslotBySchedule({ date, scheduleIds, resources, product, }: {
         date: string;
         scheduleIds?: number[];
         resources?: ProductResourceItem[];
@@ -211,7 +211,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
     }): void;
     setOtherData(key: string, value: any): void;
     getOtherData(key: string): any;
-    getProductTypeById(id: number): Promise<"duration" | "session" | "normal">;
+    getProductTypeById(id: number): Promise<"normal" | "duration" | "session">;
     /**
      * 提供给 UI 的方法，减轻 UI 层的计算压力，UI 层只需要传递 cartItemId 和 resourceCode 即返回对应的 renderList
      *
@@ -221,9 +221,30 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
      * @memberof BookingByStepImpl
      */
     getResourcesByCartItemAndCode(cartItemId: string, resourceCode: string): any;
+    /**
+     * 根据日期范围批量获取时间槽
+     * @param params 参数对象
+     * @returns Promise<Record<string, TimeSliceItem[]>> 返回日期到时间槽的映射
+     */
+    getTimeslotsScheduleByDateRange({ startDate, endDate, scheduleIds, resources, }: {
+        startDate: string;
+        endDate: string;
+        scheduleIds?: number[];
+        resources?: ProductResourceItem[];
+    }): Promise<Record<string, TimeSliceItem[]>>;
     getAvailableDateForSession(params?: {
         startDate?: string;
         endDate?: string;
         type?: 'month';
-    }): Promise<ITime[]>;
+    }): Promise<{
+        dateList: ITime[];
+        firstAvailableDate: ITime | undefined;
+    }>;
+    getAvailableDateForSessionOptimize(params?: {
+        startDate?: string;
+        endDate?: string;
+    }): Promise<{
+        dateList: any;
+        firstAvailableDate: any;
+    }>;
 }