@pisell/pisellos 0.0.568 → 0.0.569

package/lib/solution/UnifiedBookingSales/index.js

@@ -0,0 +1,1050 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  buildPlannerDiscountResult: true,
+  normalizeProductForPlanner: true,
+  buildPlannerResourcesFromV2: true,
+  collectPlannerResourceIds: true,
+  buildBookingFromAssignment: true,
+  buildBookingFromAssignments: true,
+  buildPlannerLineIdentity: true,
+  UnifiedBookingSalesImpl: true,
+  UnifiedBookingSales: true
+};
+exports.UnifiedBookingSalesImpl = exports.UnifiedBookingSales = void 0;
+exports.buildBookingFromAssignment = buildBookingFromAssignment;
+exports.buildBookingFromAssignments = buildBookingFromAssignments;
+exports.buildPlannerDiscountResult = buildPlannerDiscountResult;
+exports.buildPlannerLineIdentity = buildPlannerLineIdentity;
+exports.buildPlannerResourcesFromV2 = buildPlannerResourcesFromV2;
+exports.collectPlannerResourceIds = collectPlannerResourceIds;
+exports.normalizeProductForPlanner = normalizeProductForPlanner;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _modules = require("../../modules");
+var _getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _BookingTicket = require("../BookingTicket");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// import { BaseSalesImpl } from '../BaseSales';
+
+const OPEN_DATA_SECTION_CODES = ['sale', 'reservation', 'fulfillment', 'menu', 'workflow'];
+const OPEN_DATA_CACHE_TTL = 5 * 60 * 1000;
+function pickLocalizedText(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'object') {
+    return value.en || value.zh || value.default || Object.values(value)[0];
+  }
+  return String(value);
+}
+function resolvePlannerDiscountId(discount) {
+  return discount.discount?.resource_id ?? discount.resource_id ?? discount.id;
+}
+function resolvePlannerDiscountTitle(discount) {
+  return pickLocalizedText(discount.name || discount.format_title || discount.discount?.title || discount.title);
+}
+function isPlannerDiscountAvailable(discount) {
+  return discount.isDisabled !== true && discount.isAvailable !== false && discount.config?.isAvailable !== false;
+}
+
+/**
+ * Converts Rules/Order discount internals into a small UI-facing diagnostic. The result keeps
+ * candidate-card state separate from line-level applications: a selected card is not proof that
+ * it actually discounted a planner product.
+ */
+function buildPlannerDiscountResult(params) {
+  const {
+    customerId,
+    discountList,
+    products,
+    summaryBefore,
+    summaryAfter,
+    status,
+    preferredDiscountId,
+    preferredDiscountFound
+  } = params;
+  const items = (discountList || []).reduce((result, discount) => {
+    const id = resolvePlannerDiscountId(discount);
+    if (id !== undefined && id !== null) {
+      result.push({
+        id,
+        name: resolvePlannerDiscountTitle(discount),
+        type: discount.tag || discount.type,
+        available: isPlannerDiscountAvailable(discount),
+        selected: discount.isSelected === true,
+        savedAmount: Number(discount.savedAmount || 0) || undefined,
+        unavailableReason: discount.unavailableReason || discount.reason
+      });
+    }
+    return result;
+  }, []);
+  const discountNameById = new Map(items.map(item => [String(item.id), item.name]));
+  const applications = [];
+  (products || []).forEach(product => {
+    const productDiscounts = [...(Array.isArray(product.discount_list) ? product.discount_list : []), ...(Array.isArray(product.product_bundle) ? product.product_bundle.flatMap(bundle => bundle?.discount_list || []) : [])];
+    productDiscounts.forEach(discount => {
+      const type = discount.tag || discount.type;
+      if (!['good_pass', 'discount_card', 'product_discount_card'].includes(type)) return;
+      const discountId = resolvePlannerDiscountId(discount);
+      applications.push({
+        discountId,
+        discountName: discountId === undefined ? undefined : discountNameById.get(String(discountId)),
+        discountType: type,
+        productId: product.product_id ?? product.id,
+        productTitle: pickLocalizedText(product.title || product.name || product.product_title),
+        productUid: product.metadata?.unique_identification_number || product.unique_identification_number,
+        amount: Number(discount.amount || 0)
+      });
+    });
+  });
+  return {
+    status,
+    customerId,
+    preferredDiscountFound,
+    preferredDiscountApplied: preferredDiscountId === undefined || preferredDiscountId === null ? undefined : items.some(item => String(item.id) === String(preferredDiscountId) && item.selected) && applications.some(item => String(item.discountId) === String(preferredDiscountId)),
+    availableDiscounts: items.filter(item => item.available),
+    selectedDiscounts: items.filter(item => item.selected),
+    applications,
+    summaryBefore,
+    summaryAfter
+  };
+}
+function toNumberId(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : String(value);
+}
+
+/** Maps several legacy product shapes into the Planner's small, stable vocabulary. */
+function resolveProductKind(product) {
+  if (product.duration) return 'duration';
+  if (['session_product', 'session_ticket'].includes(product.extension_type)) return 'session';
+  if (product.cartDetailValue?.session || product._extend?.other?.session) return 'session';
+  if (Array.isArray(product['schedule.ids']) && product['schedule.ids'].length > 0) return 'session';
+  return 'normal';
+}
+function normalizeSchedule(product) {
+  const session = product.cartDetailValue?.session || product._extend?.other?.session || product.session;
+  if (session?.start_at && session?.end_at) {
+    return [{
+      start_at: session.start_at,
+      end_at: session.end_at
+    }];
+  }
+  const schedules = product.schedules || product.schedule || product._schedule;
+  if (Array.isArray(schedules)) {
+    return schedules.map(item => ({
+      start_at: item.start_at || item.start || item.start_time,
+      end_at: item.end_at || item.end || item.end_time
+    })).filter(item => item.start_at && item.end_at);
+  }
+  return [];
+}
+
+/**
+ * Preserves form ownership while flattening default/optional resource ids.
+ * `formId` must survive because the order API requires it under booking.resources[].
+ */
+function normalizeRequirements(product) {
+  const resources = product.product_resource?.resources;
+  if (!Array.isArray(resources)) return [];
+  return resources.filter(resource => resource?.status !== 0).map(resource => ({
+    formId: toNumberId(resource.id),
+    resourceIds: [...(Array.isArray(resource.default_resource) ? resource.default_resource : []), ...(Array.isArray(resource.optional_resource) ? resource.optional_resource : [])].map(id => toNumberId(id)).filter(id => id !== undefined),
+    resourceType: resource.type || resource.select_type?.type || 'single',
+    required: resource.status === 1,
+    capacityRequired: Number(product.capacity?.default || product.capacity || 1) || 1
+  }));
+}
+
+/** Converts a ProductList record into the pure input shape consumed by ResourcePlanner. */
+function normalizeProductForPlanner(product) {
+  const raw = product;
+  const kind = resolveProductKind(raw);
+  return {
+    id: raw.id ?? raw.product_id,
+    title: pickLocalizedText(raw.title || raw.name || raw.product_title),
+    kind,
+    durationMinutes: Number(raw.duration?.value || raw.duration || raw.service_duration || 30) || 30,
+    schedule: normalizeSchedule(raw),
+    resourceRequirements: normalizeRequirements(raw),
+    capacityRequired: Number(raw.capacity?.default || raw.capacity || 1) || 1,
+    quantity: Number(raw.num || raw.quantity || 1) || 1,
+    price: raw.price ?? raw.selling_price ?? raw.base_price,
+    raw
+  };
+}
+function normalizeResourceType(value) {
+  if (value === 'multiple' || value === 'capacity') return value;
+  return 'single';
+}
+function normalizeResource(raw) {
+  const id = raw.resourceId ?? raw.resource_id ?? raw.id;
+  if (id === undefined || id === null || id === '') return null;
+  const combinedResourceIds = raw.combined_resource?.resource_ids;
+  return {
+    id,
+    formId: raw.formId ?? raw.form_id ?? raw.resource_form_id,
+    name: raw.resourceName || raw.main_field || raw.name || raw.title,
+    resourceType: normalizeResourceType(raw.type || raw.resourceType || raw.select_type?.type),
+    capacity: Number(raw.capacity || raw.max_capacity || 1) || 1,
+    times: Array.isArray(raw.times) ? raw.times : [],
+    childResourceIds: Array.isArray(combinedResourceIds) ? combinedResourceIds : undefined,
+    raw
+  };
+}
+function normalizeScheduleIds(raw) {
+  const ids = raw.schedule ?? raw.schedule_ids ?? raw.scheduleIds ?? [];
+  return (Array.isArray(ids) ? ids : [ids]).map(id => toNumberId(id)).filter(id => id !== undefined);
+}
+function collectRawScheduleIds(rawResources) {
+  const ids = new Map();
+  (rawResources || []).forEach(resource => {
+    normalizeScheduleIds(resource).forEach(id => {
+      ids.set(String(id), id);
+    });
+  });
+  return Array.from(ids.values());
+}
+function scheduleListHasIds(scheduleList, scheduleIds) {
+  if (!scheduleIds.length) return true;
+  const existingIds = new Set((scheduleList || []).map(schedule => String(schedule.id)));
+  return scheduleIds.every(id => existingIds.has(String(id)));
+}
+function dateRangeDays(dateRange) {
+  if (!dateRange?.start || !dateRange?.end) return [];
+  const dates = [];
+  let cursor = (0, _dayjs.default)(dateRange.start);
+  const end = (0, _dayjs.default)(dateRange.end);
+  if (!cursor.isValid() || !end.isValid() || end.isBefore(cursor, 'day')) return dates;
+  while (cursor.isSame(end, 'day') || cursor.isBefore(end, 'day')) {
+    dates.push(cursor.format('YYYY-MM-DD'));
+    cursor = cursor.add(1, 'day');
+  }
+  return dates;
+}
+function normalizePlannerEvent(rawEvent, resourceId) {
+  const startAt = rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime;
+  const endAt = rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime;
+  if (!startAt || !endAt) return null;
+  const rawSource = rawEvent.source;
+  const source = rawSource === 'remote' || rawSource === 'cart' || rawSource === 'selection' ? rawSource : 'remote';
+  return {
+    ...rawEvent,
+    resourceId,
+    resource_id: rawEvent.resource_id ?? rawEvent.resourceId ?? resourceId,
+    start_at: startAt,
+    end_at: endAt,
+    pax: Number(rawEvent.pax ?? rawEvent.number ?? rawEvent.capacity ?? 1) || 1,
+    source
+  };
+}
+function normalizeResourceV2(raw) {
+  const normalized = normalizeResource({
+    ...raw,
+    times: []
+  });
+  if (!normalized) return null;
+  return normalized;
+}
+function buildResourceWindowFallbackTimes(params) {
+  const {
+    raw,
+    dates,
+    scheduleIds
+  } = params;
+  const rawStart = raw.start_time || raw.start_at || raw.startTime;
+  const rawEnd = raw.end_time || raw.end_at || raw.endTime;
+  if (!rawStart || !rawEnd) return [];
+  const startBoundary = (0, _dayjs.default)(rawStart);
+  const endBoundary = (0, _dayjs.default)(rawEnd);
+  if (!startBoundary.isValid() || !endBoundary.isValid() || !endBoundary.isAfter(startBoundary)) {
+    return [];
+  }
+  return dates.flatMap(date => {
+    const dayStart = (0, _dayjs.default)(`${date} 00:00:00`);
+    const dayEnd = (0, _dayjs.default)(`${date} 23:59:59`);
+    const start = startBoundary.isAfter(dayStart) ? startBoundary : dayStart;
+    const end = endBoundary.isBefore(dayEnd) ? endBoundary : dayEnd;
+    if (!end.isAfter(start)) return [];
+    return [{
+      start_at: start.format('YYYY-MM-DD HH:mm:ss'),
+      end_at: end.format('YYYY-MM-DD HH:mm:ss'),
+      schedule_ids: scheduleIds,
+      source: 'resource_window_fallback'
+    }];
+  });
+}
+
+/**
+ * Materializes resource work windows locally from v2's schedule ids, then keeps its flat
+ * event_list as planner events. This deliberately avoids the older API's times -> event_list
+ * response nesting and lets one resource response serve any requested date range.
+ */
+function buildPlannerResourcesFromV2(params) {
+  const scheduleMap = new Map((params.scheduleList || []).map(schedule => [String(schedule.id), schedule]));
+  const dates = dateRangeDays(params.dateRange);
+  const externalEvents = [];
+  const resources = (params.rawResources || []).map(raw => {
+    const resource = normalizeResourceV2(raw);
+    if (!resource) return null;
+    const scheduleIds = normalizeScheduleIds(raw);
+    const schedules = scheduleIds.map(id => scheduleMap.get(String(id))).filter(Boolean);
+    const matchedScheduleIds = new Set(schedules.map(schedule => String(schedule.id)));
+    const missingScheduleIds = scheduleIds.filter(id => !matchedScheduleIds.has(String(id)));
+    if (missingScheduleIds.length > 0) {
+      resource.raw = {
+        ...(resource.raw || raw),
+        _plannerMissingScheduleIds: missingScheduleIds
+      };
+    }
+    resource.times = dates.flatMap(date => (0, _getDateIsInSchedule.getScheduleStartEndTimePoints)(date, schedules).map(slot => ({
+      start_at: (0, _dayjs.default)(slot.start_at).format('YYYY-MM-DD HH:mm:ss'),
+      end_at: (0, _dayjs.default)(slot.end_at).format('YYYY-MM-DD HH:mm:ss'),
+      schedule_ids: scheduleIds
+    })));
+    if (resource.times.length === 0 && missingScheduleIds.length > 0) {
+      resource.times = buildResourceWindowFallbackTimes({
+        raw,
+        dates,
+        scheduleIds
+      });
+    }
+    const eventList = Array.isArray(raw.event_list) ? raw.event_list : [];
+    eventList.forEach(event => {
+      const normalizedEvent = normalizePlannerEvent(event, resource.id);
+      if (normalizedEvent) externalEvents.push(normalizedEvent);
+    });
+    return resource;
+  }).filter(resource => resource !== null);
+  return {
+    resources,
+    externalEvents
+  };
+}
+
+/** Combines URL-locked resources with every resource referenced by the selected products. */
+function collectPlannerResourceIds(products, explicitResourceIds = []) {
+  const ids = new Map();
+  const add = value => {
+    if (value === undefined || value === null || value === '') return;
+    ids.set(String(value), value);
+  };
+  explicitResourceIds.forEach(add);
+  products.forEach(product => {
+    product.resourceRequirements?.forEach(requirement => {
+      requirement.resourceIds?.forEach(add);
+    });
+  });
+  return Array.from(ids.values());
+}
+function samePlannerId(left, right) {
+  if (left === undefined || right === undefined) return false;
+  return String(left) === String(right);
+}
+function findRequirementForAssignment(product, assignment) {
+  const requirements = product.resourceRequirements || [];
+  return requirements.find(requirement => (requirement.resourceIds || []).some(id => samePlannerId(id, assignment.resourceId))) || (requirements.length === 1 ? requirements[0] : undefined) || requirements.find(requirement => requirement.required) || requirements[0];
+}
+
+/** Convenience wrapper for the usual one-resource booking case. */
+function buildBookingFromAssignment(params) {
+  return buildBookingFromAssignments({
+    assignments: [params.assignment],
+    product: params.product
+  });
+}
+
+/**
+ * Converts all resources needed by one product/time interval into the one booking expected by
+ * OrderModule. Callers must group assignments before this function so a multi-form booking does
+ * not become several competing bookings.
+ */
+function buildBookingFromAssignments(params) {
+  const {
+    assignments,
+    product
+  } = params;
+  const firstAssignment = assignments[0];
+  const start = (0, _dayjs.default)(firstAssignment.start_at);
+  const end = (0, _dayjs.default)(firstAssignment.end_at);
+  return {
+    start_date: start.format('YYYY-MM-DD'),
+    start_time: start.format('HH:mm'),
+    end_date: end.format('YYYY-MM-DD'),
+    end_time: end.format('HH:mm'),
+    duration: Math.max(1, end.diff(start, 'minute')),
+    like_status: 'common',
+    schedule_id: 0,
+    resources: assignments.map(assignment => {
+      const requirement = findRequirementForAssignment(product, assignment);
+      return {
+        id: assignment.resourceId,
+        resource_id: assignment.resourceId,
+        form_id: requirement?.formId,
+        relation_type: 'form',
+        relation_id: assignment.resourceId,
+        like_status: 'common',
+        capacity: assignment.capacityRequired || product.capacityRequired || 1
+      };
+    }),
+    metadata: {
+      unified_booking_sales: true,
+      planner_source: product.kind
+    }
+  };
+}
+function buildAssignmentGroupKey(assignment) {
+  return [assignment.productId, assignment.start_at, assignment.end_at].join(':');
+}
+
+/** Builds the exact identity BaseSales needs to remove only this solution's order lines. */
+function buildPlannerLineIdentity(product) {
+  return {
+    product_id: product.product_id,
+    product_variant_id: product.product_variant_id ?? 0,
+    unique_identification_number: product.metadata?.unique_identification_number || product.unique_identification_number,
+    product_sku: product.product_sku,
+    product_bundle: product.product_bundle
+  };
+}
+class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
+  defaultName = 'unifiedBookingSales';
+  defaultVersion = '1.0.0';
+  store = {};
+  unifiedProductCatalog = [];
+  openDataTarget = null;
+  loadOpenDataInFlight = null;
+  loadOpenDataInFlightTarget = null;
+
+  /**
+   * Kiosk 不能把已收款订单留在本地等待重试：默认直接等待云端 checkout。
+   * 兼容仍需要 WebPOS 待同步模式的入口可显式传 checkoutSyncTaskEnabled: true。
+   */
+  shouldUseCheckoutSyncTask() {
+    const configured = this.otherParams?.checkoutSyncTaskEnabled;
+    return typeof configured === 'boolean' ? configured : false;
+  }
+
+  /** UnifiedBookingSales 的真实结账默认请求收据数据，供云端确认后再本地打印。 */
+  getDefaultCheckoutSmallTicketDataFlag() {
+    return 1;
+  }
+  getRegisteredModuleNames() {
+    return [...super.getRegisteredModuleNames(), 'resourcePlanner', 'openData'];
+  }
+  createSubModule(moduleName) {
+    if (moduleName === 'resourcePlanner') {
+      return new _modules.ResourcePlannerModule(`${this.name}_resourcePlanner`);
+    }
+    if (moduleName === 'openData') {
+      return new _modules.OpenDataModule(`${this.name}_openData`);
+    }
+    return super.createSubModule(moduleName);
+  }
+
+  /**
+   * Loads OpenData without borrowing BookingTicket. Cache ownership is tied to the exact
+   * business/channel target so a reused solution instance cannot leak another entry's menus.
+   */
+  async loadOpenData(params) {
+    if (!this.store.openData) {
+      throw new Error('[UnifiedBookingSales] openData 模块未初始化');
+    }
+    const businessCode = String(params.businessCode || '').trim();
+    const channel = String(params.channel || '').trim();
+    if (!businessCode || !channel) {
+      throw new Error('[UnifiedBookingSales] OpenData 需要 businessCode 与 channel');
+    }
+    const target = `${businessCode}+${channel}`;
+    const cachedData = this.store.openData.getOpenData();
+    const lastFetchedAt = this.store.openData.getLastFetchedAt();
+    if (!params.force && this.openDataTarget === target && cachedData && lastFetchedAt && Date.now() - lastFetchedAt < OPEN_DATA_CACHE_TTL) {
+      return cachedData;
+    }
+    if (this.loadOpenDataInFlight) {
+      if (this.loadOpenDataInFlightTarget === target) {
+        return await this.loadOpenDataInFlight;
+      }
+      await this.loadOpenDataInFlight;
+      return this.loadOpenData(params);
+    }
+    this.loadOpenDataInFlightTarget = target;
+    this.loadOpenDataInFlight = this.store.openData.fetchOpenData({
+      scope: 'board',
+      target,
+      section_code: [...OPEN_DATA_SECTION_CODES]
+    });
+    try {
+      const openData = await this.loadOpenDataInFlight;
+      this.openDataTarget = target;
+      this.otherParams.openData = openData;
+      this.otherParams.businessCode = businessCode;
+      this.otherParams.channel = channel;
+      return openData;
+    } finally {
+      this.loadOpenDataInFlight = null;
+      this.loadOpenDataInFlightTarget = null;
+    }
+  }
+  async getOpenData() {
+    return this.store.openData?.getOpenData() || null;
+  }
+
+  /**
+   * Loads the product catalog used by both UI and Planner. Schedule data is requested with each
+   * product because session products carry their fixed intervals there.
+   */
+  async loadProducts(params = {}, options) {
+    if (!this.store.products) throw new Error('[UnifiedBookingSales] products 模块未初始化');
+    const schedule_date = params.schedule_date || (0, _dayjs.default)().format('YYYY-MM-DD');
+    const schedule_datetime = params.schedule_datetime || `${schedule_date} ${(0, _dayjs.default)().format('HH:mm:ss')}`;
+    const result = await this.store.products.loadProducts({
+      with_count: ['bundleGroup', 'optionGroup'],
+      with_schedule: 1,
+      ...params,
+      schedule_date,
+      schedule_datetime,
+      cacheId: this.cacheId
+    }, options);
+    this.unifiedProductCatalog = Array.isArray(result) ? [...result] : [];
+    await this.core.effects.emit(`${this.name}:onProductsLoaded`, result);
+    return result;
+  }
+
+  /** Date-first entry point. It delegates protocol details and cache ownership to ScheduleModule. */
+  async loadScheduleAvailableDate(params) {
+    if (!this.store.schedule) throw new Error('[UnifiedBookingSales] schedule 模块未初始化');
+    return this.store.schedule.loadScheduleAvailableDate(params);
+  }
+
+  /**
+   * Implements the date-first product pool: the chosen date's product ids plus globally sellable
+   * other_product_ids. If a batch product query is unexpectedly empty, retry one id at a time so
+   * a partial backend incompatibility does not hide the entire date's catalog.
+   */
+  async loadProductsByScheduleDate(params) {
+    const {
+      date,
+      custom_page_id,
+      channel,
+      product_ids,
+      ...productLoadParams
+    } = params;
+    if (!this.store.schedule) throw new Error('[UnifiedBookingSales] schedule 模块未初始化');
+    const cachedDates = this.store.schedule.getAvailabilityScheduleDateList?.() || [];
+    const hasCachedDate = cachedDates.some(item => item.date === date);
+    const hasOtherProducts = (this.store.schedule.getOtherProductsIds?.() || []).length > 0;
+    if (!hasCachedDate && !hasOtherProducts) {
+      await this.loadScheduleAvailableDate({
+        startDate: date,
+        endDate: date,
+        custom_page_id,
+        channel
+      });
+    }
+    const scheduleDate = this.store.schedule.getAvailabilityScheduleDateList?.()?.find(item => item.date === date);
+    const productIdFilter = product_ids?.length ? new Set(product_ids.map(id => String(id))) : null;
+    const availableProductIds = [...(scheduleDate?.product_ids || []), ...(this.store.schedule.getOtherProductsIds?.() || [])].filter((id, index, self) => self.indexOf(id) === index).filter(id => !productIdFilter || productIdFilter.has(String(id)));
+    if (!availableProductIds.length) {
+      this.unifiedProductCatalog = [];
+      await this.core.effects.emit(`${this.name}:onProductsLoaded`, []);
+      return [];
+    }
+    const products = await this.loadProducts({
+      ...productLoadParams,
+      product_ids: availableProductIds,
+      schedule_date: date
+    });
+    if (products.length || availableProductIds.length <= 1) return products;
+    const fallbackProducts = [];
+    for (const productId of availableProductIds) {
+      const result = await this.loadProducts({
+        ...productLoadParams,
+        product_ids: [productId],
+        schedule_date: date
+      });
+      result.forEach(product => {
+        const id = product?.id ?? product?.product_id;
+        if (!fallbackProducts.some(item => String(item?.id ?? item?.product_id) === String(id))) {
+          fallbackProducts.push(product);
+        }
+      });
+    }
+    this.unifiedProductCatalog = [...fallbackProducts];
+    await this.core.effects.emit(`${this.name}:onProductsLoaded`, fallbackProducts);
+    return fallbackProducts;
+  }
+
+  /** Returns a copy so UI consumers cannot accidentally mutate the solution's product cache. */
+  getProductCatalog() {
+    return {
+      products: [...this.unifiedProductCatalog]
+    };
+  }
+
+  /**
+   * Read-only compatibility view for salesSdk skins. It reconnects a booking to its product but
+   * must not be used to mutate tempOrder; all writes go through BaseSales / planner APIs.
+   */
+  getCart() {
+    const tempOrder = this.getTempOrder();
+    const salesDetail = this.getSalesOrder();
+    const items = tempOrder?.products || [];
+    const bookings = salesDetail?.bookings || tempOrder?.bookings || [];
+    return {
+      items,
+      bookings: bookings.map(booking => {
+        const productUid = booking?.product_uid;
+        const product = productUid ? items.find(item => {
+          const uid = item?.metadata?.unique_identification_number || item?.unique_identification_number;
+          return String(uid || '') === String(productUid);
+        }) || null : null;
+        return {
+          ...booking,
+          _extend: {
+            ...(booking?._extend || {}),
+            product,
+            addTimeProduct: [],
+            canAddTime: false
+          }
+        };
+      })
+    };
+  }
+
+  /**
+   * Loads the current customer's product coupons and discount cards after planner lines exist,
+   * then optionally lets the existing Rules engine select the best valid combination. This is a
+   * diagnostic boundary for new booking skins: no pricing logic is duplicated in the planner.
+   */
+  async applyPlannerDiscounts(params = {}) {
+    const tempOrder = this.getTempOrder();
+    const requestedCustomerId = params.customerId ?? tempOrder?.customer_id;
+    const parsedCustomerId = Number(requestedCustomerId);
+    const customerId = Number.isFinite(parsedCustomerId) && parsedCustomerId > 1 ? parsedCustomerId : null;
+    const summaryBefore = await this.getSummary();
+    if (!customerId) {
+      return buildPlannerDiscountResult({
+        customerId: null,
+        discountList: this.getDiscountList(),
+        products: tempOrder?.products || [],
+        summaryBefore,
+        summaryAfter: summaryBefore,
+        status: 'no_customer'
+      });
+    }
+    await this.loadDiscountConfig({
+      customerId,
+      action: 'create'
+    });
+    const preferredDiscountId = params.preferredDiscountId;
+    const preferredDiscount = preferredDiscountId === undefined || preferredDiscountId === null ? undefined : this.getDiscountList().find(discount => String(resolvePlannerDiscountId(discount) ?? '') === String(preferredDiscountId));
+    if (preferredDiscount) {
+      // A requested card is an explicit UI choice, not a best-effort preference. Clear prior
+      // automatic selections first; otherwise Rules may keep the old selected card and silently
+      // apply it instead of the card the customer clicked.
+      const preferredId = resolvePlannerDiscountId(preferredDiscount);
+      const selectedOtherDiscounts = this.getDiscountList().filter(discount => discount.isSelected === true && String(resolvePlannerDiscountId(discount) ?? '') !== String(preferredId));
+      for (const discount of selectedOtherDiscounts) {
+        const discountId = Number(resolvePlannerDiscountId(discount));
+        if (Number.isFinite(discountId)) {
+          await this.setDiscountSelected({
+            discountId,
+            isSelected: false
+          });
+        }
+      }
+      await this.setDiscountSelected({
+        discountId: Number(preferredId),
+        isSelected: true
+      });
+    } else if (preferredDiscountId === undefined || preferredDiscountId === null) {
+      if (params.applyBestDiscount !== false) await this.bestDiscount();
+    } else if (params.applyBestDiscount !== false) {
+      await this.bestDiscount();
+    }
+    const nextTempOrder = this.getTempOrder();
+    return buildPlannerDiscountResult({
+      customerId,
+      discountList: this.getDiscountList(),
+      products: nextTempOrder?.products || [],
+      summaryBefore,
+      summaryAfter: await this.getSummary(),
+      status: params.applyBestDiscount === false && !preferredDiscount ? 'loaded' : 'applied',
+      preferredDiscountId,
+      preferredDiscountFound: preferredDiscountId === undefined || preferredDiscountId === null ? undefined : Boolean(preferredDiscount)
+    });
+  }
+
+  /** ResourcePlanner is a required child module; fail early instead of producing partial availability. */
+  getPlanner() {
+    if (!this.store.resourcePlanner) {
+      throw new Error('[UnifiedBookingSales] resourcePlanner 模块未初始化');
+    }
+    return this.store.resourcePlanner;
+  }
+  buildUnifiedOrderProduct(sourceProduct, ownershipKey, product) {
+    const orderProduct = this.transformBaseProductToOrderProduct({
+      payload: {
+        ...sourceProduct,
+        id: sourceProduct.id ?? product?.id,
+        product_id: sourceProduct.product_id ?? sourceProduct.id ?? product?.id,
+        quantity: sourceProduct.quantity ?? sourceProduct.num ?? product?.quantity ?? 1,
+        price: sourceProduct.price ?? product?.price,
+        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? product?.price,
+        metadata: {
+          ...(sourceProduct.metadata || {}),
+          [ownershipKey]: true
+        }
+      },
+      sourceProduct
+    });
+    if (orderProduct && typeof orderProduct === 'object') {
+      // BaseSales may rebuild metadata from its price source. Stamp ownership after that transform
+      // so each UnifiedBookingSales entry point can replace only its own temporary lines.
+      orderProduct.metadata = {
+        ...(orderProduct.metadata || {}),
+        [ownershipKey]: true
+      };
+    }
+    return orderProduct;
+  }
+
+  /** Replacing a staged selection is idempotent and never removes unrelated cart lines. */
+  async removeExistingStagedLines(ownershipKey) {
+    const existingLines = (this.getTempOrder()?.products || []).filter(product => product?.metadata?.[ownershipKey] === true);
+    if (existingLines.length > 0) {
+      await this.removeProductsFromOrder(existingLines.map(buildPlannerLineIdentity));
+    }
+  }
+  async stageProducts(params, ownershipKey) {
+    const productIds = params.productIds || [];
+    if (!productIds.length) return this.getTempOrder();
+    if (params.rawProducts?.length) {
+      this.unifiedProductCatalog = params.rawProducts;
+    } else {
+      const existingIds = new Set((this.unifiedProductCatalog || []).map(product => String(product.id ?? product.product_id)));
+      const missingIds = productIds.filter(id => !existingIds.has(String(id)));
+      if (missingIds.length || params.productLoadParams) {
+        await this.loadProducts({
+          ...(params.productLoadParams || {}),
+          product_ids: productIds.map(Number).filter(Number.isFinite)
+        });
+      }
+    }
+    await this.removeExistingStagedLines(ownershipKey);
+    const productIdSet = new Set(productIds.map(id => String(id)));
+    const selectedProducts = (this.unifiedProductCatalog || []).filter(product => productIdSet.has(String(product.id ?? product.product_id)));
+    for (const sourceProduct of selectedProducts) {
+      const productInput = this.buildUnifiedOrderProduct(sourceProduct, ownershipKey);
+      if (productInput) await this.addProductToOrder(productInput);
+    }
+    return this.getTempOrder();
+  }
+
+  /**
+   * Adds the current product choice to an otherwise clean planner cart without creating bookings.
+   * This separates "what the customer wants" from the later time/resource confirmation step.
+   */
+  async stagePlannerProducts(params) {
+    return this.stageProducts(params, 'unified_booking_sales');
+  }
+
+  /**
+   * Adds ordinary retail products without asking ResourcePlanner for booking facts.
+   * Its staged lines have separate ownership so planner and retail skins can coexist safely.
+   */
+  async stageRetailProducts(params) {
+    return this.stageProducts(params, 'unified_booking_sales_retail');
+  }
+
+  /**
+   * Adds one retail line without replacing the cart's existing retail selection.
+   * This is intentionally separate from stageRetailProducts(), whose contract is
+   * "replace the staged selection" for demo and wizard-like callers.
+   */
+  async addRetailProduct(params) {
+    const quantity = Math.floor(Number(params.quantity ?? 1));
+    if (!Number.isFinite(quantity) || quantity <= 0) {
+      throw new Error('[UnifiedBookingSales] retail 商品数量必须大于 0');
+    }
+    const productId = params.productId ?? params.product?.id ?? params.product?.product_id;
+    let sourceProduct = params.product;
+    if (!sourceProduct && productId !== undefined && productId !== null) {
+      sourceProduct = this.unifiedProductCatalog.find(product => String(product.id ?? product.product_id) === String(productId));
+    }
+    if (!sourceProduct && productId !== undefined && productId !== null) {
+      const products = await this.loadProducts({
+        ...(params.productLoadParams || {}),
+        product_ids: [Number(productId)].filter(Number.isFinite)
+      });
+      sourceProduct = products.find(product => String(product.id ?? product.product_id) === String(productId));
+    }
+    if (!sourceProduct) {
+      throw new Error(`[UnifiedBookingSales] 未找到零售商品 ${String(productId ?? '')}`.trim());
+    }
+    const orderProduct = this.buildUnifiedOrderProduct({
+      ...sourceProduct,
+      quantity
+    }, 'unified_booking_sales_retail');
+    if (!orderProduct) {
+      throw new Error('[UnifiedBookingSales] 无法生成零售商品订单行');
+    }
+    return this.addProductToOrder(orderProduct);
+  }
+
+  /** Normalizes caller-provided products or loads the catalog before any resource request is made. */
+  async loadPlannerProducts(params) {
+    if (params.context?.products?.length) return params.context.products;
+    if (params.rawProducts?.length) return params.rawProducts.map(normalizeProductForPlanner);
+    const productIds = params.productIds || params.productLoadParams?.product_ids || [];
+    if (productIds.length > 0 || params.productLoadParams) {
+      await this.loadProducts({
+        ...(params.date ? {
+          schedule_date: params.date
+        } : {}),
+        ...(params.productLoadParams || {}),
+        product_ids: productIds.length ? productIds.map(Number).filter(Number.isFinite) : params.productLoadParams?.product_ids
+      });
+    }
+    return (this.getProductCatalog?.().products || []).map(normalizeProductForPlanner);
+  }
+
+  /** Loads the reusable store-level schedule catalog on demand. */
+  async ensurePlannerSchedulesLoaded() {
+    if (!this.store.schedule) throw new Error('[UnifiedBookingSales] schedule 模块未初始化');
+    const scheduleList = this.store.schedule.getScheduleList?.() || [];
+    if (!this.store.schedule.isScheduleListLoaded?.() || scheduleList.length === 0) {
+      await this.store.schedule.loadAllSchedule();
+    }
+    return this.store.schedule.getScheduleList?.() || [];
+  }
+
+  /**
+   * v2 resources reference schedule ids rather than expanded work times. Refresh once when the
+   * cached schedule catalog cannot materialize all referenced ids.
+   */
+  async ensurePlannerSchedulesForResources(rawResources) {
+    let scheduleList = await this.ensurePlannerSchedulesLoaded();
+    const scheduleIds = collectRawScheduleIds(rawResources);
+    if (!scheduleListHasIds(scheduleList, scheduleIds)) {
+      await this.store.schedule.loadAllSchedule({
+        useCache: false
+      });
+      scheduleList = this.store.schedule.getScheduleList?.() || [];
+    }
+    return scheduleList;
+  }
+
+  /**
+   * Fetches resource metadata plus flat occupied events. Work windows are intentionally derived
+   * locally in buildPlannerResourcesFromV2 from /schedule, rather than requested from the legacy
+   * resource dates endpoint.
+   */
+  async fetchPlannerResourcesV2(params) {
+    const response = await this.request.get('/schedule/resource/list/v2', {
+      start_date: params.dateRange.start,
+      end_date: params.dateRange.end,
+      resource_ids: params.resourceIds,
+      front_end_cache_id: false
+    }, {
+      useCache: false
+    });
+    const data = response?.data;
+    if (Array.isArray(data)) return data;
+    if (Array.isArray(data?.list)) return data.list;
+    return [];
+  }
+
+  /**
+   * Resolves the Planner context in precedence order: explicit normalized context, test raw data,
+   * then the v2 resource API inferred from selected product requirements and any URL lock.
+   */
+  async loadPlannerResources(params, products = []) {
+    if (params.context?.resources?.length) {
+      return {
+        resources: params.context.resources,
+        externalEvents: params.context.externalEvents || []
+      };
+    }
+    if (params.rawResources?.length) {
+      return {
+        resources: params.rawResources.map(normalizeResource).filter(resource => resource !== null),
+        externalEvents: params.context?.externalEvents || []
+      };
+    }
+    const resourceIds = collectPlannerResourceIds(products, params.resourceIds || []);
+    if (!params.useResourceDateApi || !params.dateRange || resourceIds.length === 0) {
+      return {
+        resources: [],
+        externalEvents: params.context?.externalEvents || []
+      };
+    }
+    const rawResources = await this.fetchPlannerResourcesV2({
+      dateRange: params.dateRange,
+      resourceIds
+    });
+    const scheduleList = await this.ensurePlannerSchedulesForResources(rawResources);
+    const materialized = buildPlannerResourcesFromV2({
+      rawResources,
+      scheduleList,
+      dateRange: params.dateRange
+    });
+    return {
+      resources: materialized.resources,
+      externalEvents: [...(params.context?.externalEvents || []), ...materialized.externalEvents]
+    };
+  }
+
+  /**
+   * Boundary between IO and pure planning. Once this returns, all later availability/slot calls
+   * operate on the ResourcePlanner snapshot and do not issue resource requests themselves.
+   */
+  async loadPlannerContext(params = {}) {
+    const products = await this.loadPlannerProducts(params);
+    const plannerResources = await this.loadPlannerResources(params, products);
+    const context = {
+      ...(params.context || {}),
+      products,
+      resources: plannerResources.resources,
+      externalEvents: plannerResources.externalEvents
+    };
+    const snapshot = this.getPlanner().setContext(context);
+    this.getPlanner().setSelectionPatch({
+      mode: params.mode,
+      productIds: params.productIds || [],
+      date: params.date,
+      startTime: params.startTime,
+      endTime: params.endTime,
+      resourceIds: params.resourceIds || []
+    });
+    await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onPlannerContextLoaded}`, snapshot);
+    return this.getPlanner().getSnapshot();
+  }
+
+  /** Returns cells, date summaries and a derived grid; cells are continuous ranges, not UI slots. */
+  async queryPlannerAvailability(query = {}) {
+    return this.getPlanner().queryAvailability(query);
+  }
+
+  /** Turns compatible availability ranges into user-selectable intervals and ready-to-commit assignments. */
+  resolveAssignableSlots(query = {}) {
+    return this.getPlanner().resolveAssignableSlots(query);
+  }
+
+  /** Stores a UI choice only. It is deliberately side-effect free with respect to tempOrder. */
+  setPlannerSelection(patch) {
+    return this.getPlanner().setSelectionPatch(patch);
+  }
+
+  /**
+   * Legacy-friendly automatic assignment for already fixed intervals. Duration products without a
+   * start time intentionally remain unresolved; callers offering a picker should use slots.
+   */
+  async autoAssignPlanner(query = {}) {
+    const result = this.getPlanner().autoAssign(query);
+    if (result.conflicts.length) {
+      console.warn('[UnifiedBookingSales] autoAssignPlanner 存在未分配项', result.conflicts);
+    }
+    return this.getPlanner().getSnapshot();
+  }
+
+  /** Rechecks remote events, capacity and conflicts among the current selection before committing. */
+  validatePlannerSelection() {
+    return this.getPlanner().validateSelection();
+  }
+
+  /** Read-only snapshot for UI diagnostics and progressive flow steps. */
+  getPlannerSnapshot() {
+    return this.getPlanner().getSnapshot();
+  }
+
+  /**
+   * Validates then writes assignments to tempOrder. Real order submission is opt-in so UI callers
+   * can safely preview the cart; pass submitAfterCommit only after an explicit confirmation.
+   */
+  async commitPlannerSelection(params = {}) {
+    if (params.selection) {
+      this.setPlannerSelection(params.selection);
+    }
+    if (params.assignments) {
+      this.setPlannerSelection({
+        assignments: params.assignments
+      });
+    }
+    const snapshot = this.getPlannerSnapshot();
+    const assignments = snapshot.selection.assignments || [];
+    if (assignments.length === 0) {
+      return {
+        tempOrder: this.getTempOrder(),
+        assignments,
+        validation: {
+          ok: false,
+          conflicts: [{
+            type: 'missing_assignment',
+            message: '没有可提交的 planner assignment，请先执行 autoAssignPlanner 或传入 assignments'
+          }]
+        }
+      };
+    }
+    const validation = this.validatePlannerSelection();
+    if (!validation.ok) {
+      return {
+        tempOrder: this.getTempOrder(),
+        assignments,
+        validation
+      };
+    }
+    const productsById = new Map(snapshot.context.products.map(product => [String(product.id), product]));
+    await this.removeExistingStagedLines('unified_booking_sales');
+    const assignmentGroups = new Map();
+    assignments.forEach(assignment => {
+      const key = buildAssignmentGroupKey(assignment);
+      assignmentGroups.set(key, [...(assignmentGroups.get(key) || []), assignment]);
+    });
+    for (const groupAssignments of assignmentGroups.values()) {
+      const product = productsById.get(String(groupAssignments[0].productId));
+      if (!product) continue;
+      const sourceProduct = product.raw || {
+        id: product.id,
+        title: product.title,
+        price: product.price
+      };
+      const productInput = this.buildUnifiedOrderProduct(sourceProduct, 'unified_booking_sales', product);
+      if (!productInput) continue;
+      await this.addProductToOrder(productInput, buildBookingFromAssignments({
+        assignments: groupAssignments,
+        product
+      }));
+    }
+    let submitResult;
+    if (params.submitAfterCommit) {
+      submitResult = await this.submitSalesOrder();
+    }
+    const result = {
+      tempOrder: this.getTempOrder(),
+      assignments,
+      validation,
+      submitResult
+    };
+    await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onPlannerCommitted}`, result);
+    return result;
+  }
+}
+exports.UnifiedBookingSalesImpl = UnifiedBookingSalesImpl;
+const UnifiedBookingSales = exports.UnifiedBookingSales = UnifiedBookingSalesImpl;