@pisell/pisellos 0.10.21 → 0.10.23

package/lib/modules/ResourcePlanner/planner.js

@@ -11,8 +11,8 @@ var _types = require("./types");
 var _localClock = require("./localClock");
 const DEFAULT_SLOT_STEP_MINUTES = 30;
 const DEFAULT_BUSINESS_HOURS = {
-  startTime: '09:00',
-  endTime: '18:00'
+  startTime: '00:00',
+  endTime: '00:00'
 };
 function availabilityError(code, message, details) {
   return new _types.AvailabilityError(code, message, details);
@@ -48,6 +48,19 @@ function normalizeBookingCount(bookingCount) {
   }
   return normalized;
 }
+function resolveRequestedDurationMinutes(product, request) {
+  const configured = Math.max(1, Number(product.durationMinutes || 30) || 30);
+  if (product.kind !== 'duration') return configured;
+  const override = request.durationMinutesByProductId?.[String(product.id)];
+  const normalized = Number(override);
+  return Number.isInteger(normalized) && normalized > 0 ? normalized : configured;
+}
+function resolveRequestedDurationStartTimes(product, request) {
+  if (product.kind !== 'duration') return [];
+  const values = request.durationStartTimesByProductId?.[String(product.id)];
+  if (!Array.isArray(values)) return [];
+  return Array.from(new Set(values.filter(value => typeof value === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/.test(value))));
+}
 function toDateTime(value, _timezoneName) {
   try {
     return (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(value));
@@ -75,6 +88,9 @@ function addMinutesZoned(value, minutes, _timezoneName) {
 function ceilToTenMinutes(value, _timezoneName) {
   return (0, _localClock.ceilLocalScalarToTenMinutes)(value);
 }
+function floorToMinute(value) {
+  return Math.floor(value / 60000) * 60000;
+}
 function nextDate(value, _timezoneName) {
   return (0, _localClock.nextDate)(value);
 }
@@ -865,9 +881,30 @@ function dedupeProductRanges(ranges) {
   });
   return Array.from(map.values()).sort((left, right) => left.startAt.localeCompare(right.startAt));
 }
-function getProductTimeRanges(projection, request = {}) {
+function createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes) {
+  const bookingEnd = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+  return createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes);
+}
+function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes) {
+  return {
+    key: `${String(product.id)}:${start}:${bookingEnd}`,
+    productId: product.id,
+    source: 'duration_window',
+    startAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    bookingStartAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    date: formatDate(start, projection.meta.timezone),
+    startTime: formatTime(start, projection.meta.timezone),
+    endTime: formatTime(bookingEnd, projection.meta.timezone),
+    timezone: projection.meta.timezone,
+    scheduleRefs: []
+  };
+}
+function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
   const normalizedPartySize = normalizePartySize(request.partySize);
   const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const slotStepMinutes = projection.meta.defaults.slotStepMinutes;
   const fixedOffsetMinutes = (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)();
   const resourceWindowIndex = buildResourceWindowIndex(projection);
   const filteredProductIdSet = request.productIds?.length ? new Set(request.productIds.map(String)) : null;
@@ -877,6 +914,7 @@ function getProductTimeRanges(projection, request = {}) {
         productId: product.id,
         title: product.title,
         kind: product.kind,
+        slotStepMinutes,
         ranges: []
       };
     }
@@ -885,6 +923,7 @@ function getProductTimeRanges(projection, request = {}) {
         productId: product.id,
         title: product.title,
         kind: product.kind,
+        slotStepMinutes,
         ranges: getSessionRangesForProduct(projection, product, dateRange)
       };
     }
@@ -900,11 +939,30 @@ function getProductTimeRanges(projection, request = {}) {
       resourceWindowIndex
     })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
     const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
-    const durationMinutes = Math.max(1, Number(product.durationMinutes || 30) || 30);
-    const timeSliceMinutes = projection.meta.defaults.slotStepMinutes;
+    const durationMinutes = resolveRequestedDurationMinutes(product, request);
+    const flexibleStartAt = (() => {
+      if (!product.isFlexibleDuration) return undefined;
+      const evaluatedAt = toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt, projection.meta.timezone);
+      if (!Number.isFinite(evaluatedAt)) {
+        throw availabilityError('INVALID_TARGET_FILTER', 'runtimeOptions.evaluatedAt 必须是有效时间', {
+          evaluatedAt: runtimeOptions.evaluatedAt
+        });
+      }
+      return floorToMinute(evaluatedAt);
+    })();
     const durationAnchor = ceilToTenMinutes(toDateTime(projection.meta.durationCandidateAnchorAt, projection.meta.timezone), projection.meta.timezone);
+    const requestedStartTimes = resolveRequestedDurationStartTimes(product, request);
     const ranges = [];
     baseRanges.forEach(range => {
+      if (product.isFlexibleDuration && flexibleStartAt !== undefined) {
+        const start = Math.max(range.start, flexibleStartAt);
+        if (start >= range.end) return;
+        const bookingDate = formatDate(start);
+        if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
+          ranges.push(createDurationTimeRangeWithEnd(product, start, range.end, projection, fixedOffsetMinutes));
+        }
+        return;
+      }
       if (range.end <= durationAnchor) return;
       let cursor = range.start;
       if (cursor < durationAnchor) {
@@ -915,28 +973,28 @@ function getProductTimeRanges(projection, request = {}) {
         if (bookingEnd > range.end) break;
         const bookingDate = formatDate(cursor);
         if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
-          ranges.push({
-            key: `${String(product.id)}:${cursor}:${bookingEnd}`,
-            productId: product.id,
-            source: 'duration_window',
-            startAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
-            endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
-            bookingStartAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
-            bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
-            date: formatDate(cursor, projection.meta.timezone),
-            startTime: formatTime(cursor, projection.meta.timezone),
-            endTime: formatTime(bookingEnd, projection.meta.timezone),
-            timezone: projection.meta.timezone,
-            scheduleRefs: []
-          });
+          ranges.push(createDurationTimeRange(product, cursor, durationMinutes, projection, fixedOffsetMinutes));
         }
-        cursor = addMinutesZoned(cursor, timeSliceMinutes, projection.meta.timezone);
+        cursor = addMinutesZoned(cursor, slotStepMinutes, projection.meta.timezone);
       }
     });
+    if (dateRange.startDate === dateRange.endDate && requestedStartTimes.length > 0) {
+      requestedStartTimes.forEach(startTime => {
+        const start = toDateTimeInDate(dateRange.startDate, startTime, projection.meta.timezone);
+        if (!Number.isFinite(start)) return;
+        const end = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+        const startsInOperatingRange = operatingRanges.some(range => range.start <= start && start < range.end);
+        if (!startsInOperatingRange && !request.allowOutsideOperatingHoursForRequestedStartTimes) {
+          return;
+        }
+        ranges.push(createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes));
+      });
+    }
     return {
       productId: product.id,
       title: product.title,
       kind: product.kind,
+      slotStepMinutes,
       ranges: dedupeProductRanges(ranges)
     };
   });
@@ -1560,6 +1618,8 @@ function queryAvailabilityProjection(projection, request) {
     dateRange,
     resourceIds: request.resourceIds,
     partySize: normalizedPartySize
+  }, {
+    evaluatedAt
   });
   const candidateGroupMap = new Map(candidateGroups.map(group => [String(group.productId), group]));
   if (request.target === 'date') {

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

@@ -81,6 +81,7 @@ export interface AvailabilityProduct {
     id: AvailabilityId;
     title?: string;
     kind: AvailabilityProductKind;
+    isFlexibleDuration?: boolean;
     durationMinutes?: number;
     quantity?: number;
     capacityRequired?: number;
@@ -211,6 +212,7 @@ export interface ProductTimeRangeGroup {
     productId: AvailabilityId;
     title?: string;
     kind: AvailabilityProductKind;
+    slotStepMinutes?: number;
     ranges: ProductTimeRange[];
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
@@ -231,6 +233,16 @@ export interface GetProductTimeRangesRequest {
     dateRange?: Partial<AvailabilityDateRange>;
     resourceIds?: AvailabilityId[];
     partySize?: number;
+    durationMinutesByProductId?: Record<string, number>;
+    durationStartTimesByProductId?: Record<string, string[]>;
+    /**
+     * POS 手工输入时间的兼容开关：只为明确请求的 start time 补候选，
+     * 不改变常规候选列表仍按营业时间生成的规则。
+     */
+    allowOutsideOperatingHoursForRequestedStartTimes?: boolean;
+}
+export interface GetProductTimeRangesRuntimeOptions {
+    evaluatedAt?: string;
 }
 export interface QueryAvailabilityBaseRequest {
     productIds?: AvailabilityId[];

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

@@ -14,6 +14,11 @@ export declare class RulesModule extends BaseModule implements Module, RulesModu
     setRulesList(rulesList: Rules[]): Promise<void>;
     getRulesList(): Rules[];
     getWalletPassEvaluator(): import("../..").WalletPassEvaluator | undefined;
+    private normalizeHolderRecordIds;
+    /**
+     * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+     * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+     */
     private checkHolderMatch;
     isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, orderTotalAmount, holders, isFormSubject, }: {
         oldDiscountList: Discount[];

package/lib/modules/Rules/index.js

@@ -38,21 +38,30 @@ class RulesModule extends _BaseModule.BaseModule {
   getWalletPassEvaluator() {
     return this.window.getWalletPassEvaluator?.();
   }
+  normalizeHolderRecordIds(value) {
+    const records = Array.isArray(value) ? value : [value];
+    return Array.from(new Set(records.map(record => {
+      if (record && typeof record === 'object') {
+        return record.form_record_id;
+      }
+      return record;
+    }).filter(record => record !== undefined && record !== null && record !== '' && record !== 0 && record !== '0').map(String)));
+  }
 
-  // 商品不需要holder,则不需要判断，直接返回true，商品需要holder但是还没填写，那么暂时不使用带有holder的券，直到填写才去匹配
+  /**
+   * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+   * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+   */
   checkHolderMatch(discount, product, holders) {
     // 非表单类型 holder 视为匹配
     if (discount.holder?.holder_type !== 'form') return true;
-    // 主预约holder, 目前（20251124）默认只考虑单个holder的情况
-    // 旧版 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;
-    // 商品需要holder，但父预约及商品都无holder，返回false
-    if (!orderHolderId && !productHolderId) return false;
-    // 最终直接匹配 holder 是否相同
-    return (productHolderId || orderHolderId) === discount.holder.holder_id;
+    const discountHolderIds = this.normalizeHolderRecordIds(discount.holder.holder_id);
+    if (!discountHolderIds.length) return false;
+    const productHolderIds = this.normalizeHolderRecordIds(product.holder_id);
+    const candidateHolderIds = productHolderIds.length ? productHolderIds : this.normalizeHolderRecordIds(holders);
+    if (!candidateHolderIds.length) return false;
+    const discountHolderIdSet = new Set(discountHolderIds);
+    return candidateHolderIds.some(holderId => discountHolderIdSet.has(holderId));
   }
 
   // 判断discountList 是否可以对当前productList生效

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

@@ -129,8 +129,23 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
      */
     protected preferAuthoritativeProductQueryPrice(): boolean;
     private getPriceQuerySchedule;
+    private isCustomerUserPriceQuery;
+    private getPriceQueryScheduleList;
+    private buildPriceQueryPayload;
+    private getRawProductPriceSources;
+    private rememberRawProductPriceSources;
+    private getSelectedProductVariantId;
+    /**
+     * 将目录原始商品还原为本次选择的 SKU 基线。
+     *
+     * 这里绝不能复用已评估后的目录商品，否则从命中智能价切回不命中的
+     * 日期时会残留旧价格。套餐仅验证所选关系存在，最终仍由 merge 方法把
+     * 评估后的套餐价格映射回用户的选择数据。
+     */
+    private prepareRawProductForPriceQuery;
+    private resolveLocalProductForPriceQuery;
     private loadProductsForPriceQuery;
-    private loadProductForPriceQuery;
+    private resolveProductsForPriceQuery;
     private getAuthoritativeBundleItems;
     private findAuthoritativeBundleItem;
     private getAuthoritativeBundleUnitPrice;