@pisell/pisellos 2.2.261 → 2.2.262

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

@@ -198,6 +198,7 @@ export interface OrderProduct extends OrderProductIdentity {
     product_bundle: any[];
     booking_uid?: string;
     product_title?: OrderLocalizedText;
+    product_cover?: string;
     metadata: Record<string, any>;
     note?: string;
 }
@@ -308,6 +309,7 @@ export interface OrderState {
     lastOrderInfo?: Record<string, any>;
     syncState?: OrderSyncState;
     discountList: any[];
+    availableWalletIds?: number[];
     discount: DiscountModule | null;
     rules: RulesModule | null;
 }
@@ -340,6 +342,19 @@ export interface UpdateOrderProductParams {
      * });
      */
     allow_booking_reprice?: boolean;
+    /**
+     * Change time 重报价后，允许当前预约商品行重新应用已选编辑态折扣卡。
+     *
+     * @example
+     * await order.updateOrderProduct({
+     *   product_id: 1,
+     *   product_variant_id: 0,
+     *   updates: { discount_list: [] },
+     *   booking: { duration: 2 },
+     *   allow_booking_discount_reapply: true,
+     * });
+     */
+    allow_booking_discount_reapply?: boolean;
 }
 /** 仅更新购物车行数量；行定位语义与 updateOrderProduct / removeProductFromOrder 保持一致 */
 export interface UpdateOrderProductQuantityParams extends OrderProductIdentity {
@@ -761,6 +776,7 @@ export interface OrderModuleAPI {
         apply?: boolean;
     }) => Promise<Discount[]>;
     getDiscountList: () => Discount[];
+    getAvailableWalletIds: () => number[];
     applyDiscount: () => void;
     /**
      * 注入促销评估器。

package/lib/modules/Order/utils/orderCollectionIdentity.d.ts

@@ -0,0 +1,53 @@
+export type OrderCollectionKind = 'product' | 'booking' | 'payment';
+export interface OrderCollectionIdentityStats {
+    backfilledUidCount: number;
+    collapsedDuplicateCount: number;
+    uidConflictCount: number;
+    anonymousRowCount: number;
+}
+export interface OrderCollectionUidRemap {
+    kind: OrderCollectionKind;
+    from: string;
+    to: string;
+    persistentId: string | null;
+    /** 默认全局迁移；UID 冲突时只能迁移能由另一侧 UID 明确定位的引用。 */
+    scope?: 'global' | 'linked-owner';
+    referenceOwnerUid?: string | null;
+}
+export interface NormalizeOrderCollectionResult<T> {
+    items: T[];
+    stats: OrderCollectionIdentityStats;
+    uidRemaps: OrderCollectionUidRemap[];
+}
+export interface NormalizeOrderCollectionsResult<T> {
+    order: T;
+    stats: Record<OrderCollectionKind, OrderCollectionIdentityStats>;
+    uidRemaps: OrderCollectionUidRemap[];
+}
+export declare function createUuidV4(): string;
+export declare function isBlankOrderCollectionIdentity(value: unknown): boolean;
+export declare function getOrderCollectionPersistentId(kind: OrderCollectionKind, item: unknown): string | null;
+export declare function getOrderCollectionUid(kind: OrderCollectionKind, item: unknown): string | null;
+export declare function buildOrderCollectionFallbackUid(kind: OrderCollectionKind, persistentId: string | number): string;
+export declare function getOrderCollectionReferenceUid(kind: OrderCollectionKind, item: unknown): string | null;
+export declare function setOrderCollectionUid<T>(kind: OrderCollectionKind, item: T, uid: string): T;
+/**
+ * 持久化行 ID 是服务端事实主键；只有至少一侧尚未持久化时，才允许用 runtime UID 对齐。
+ */
+export declare function isSameOrderCollectionItem(kind: OrderCollectionKind, left: unknown, right: unknown): boolean;
+export declare function mergeOrderCollectionItems<T>(kind: OrderCollectionKind, currentItem: T, incomingItem: T, options?: {
+    ensureUid?: boolean;
+    createAnonymousUid?: () => string;
+}): T;
+/**
+ * 规范化单一数组：强身份重复时保留首次位置、用最后一条业务字段覆盖，并统一补 UID。
+ */
+export declare function normalizeOrderCollection<T>(kind: OrderCollectionKind, items: T[] | null | undefined, options?: {
+    ensureUid?: boolean;
+    createAnonymousUid?: () => string;
+}): NormalizeOrderCollectionResult<T>;
+export declare function applyOrderCollectionUidRemaps<T extends Record<string, any>>(sourceOrder: T, uidRemaps: OrderCollectionUidRemap[]): T;
+export declare function normalizeOrderCollections<T extends Record<string, any>>(sourceOrder: T, options?: {
+    ensureUid?: boolean;
+    createAnonymousUid?: () => string;
+}): NormalizeOrderCollectionsResult<T>;

package/lib/modules/Order/utils/orderCollectionIdentity.js

@@ -0,0 +1,415 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Order/utils/orderCollectionIdentity.ts
+var orderCollectionIdentity_exports = {};
+__export(orderCollectionIdentity_exports, {
+  applyOrderCollectionUidRemaps: () => applyOrderCollectionUidRemaps,
+  buildOrderCollectionFallbackUid: () => buildOrderCollectionFallbackUid,
+  createUuidV4: () => createUuidV4,
+  getOrderCollectionPersistentId: () => getOrderCollectionPersistentId,
+  getOrderCollectionReferenceUid: () => getOrderCollectionReferenceUid,
+  getOrderCollectionUid: () => getOrderCollectionUid,
+  isBlankOrderCollectionIdentity: () => isBlankOrderCollectionIdentity,
+  isSameOrderCollectionItem: () => isSameOrderCollectionItem,
+  mergeOrderCollectionItems: () => mergeOrderCollectionItems,
+  normalizeOrderCollection: () => normalizeOrderCollection,
+  normalizeOrderCollections: () => normalizeOrderCollections,
+  setOrderCollectionUid: () => setOrderCollectionUid
+});
+module.exports = __toCommonJS(orderCollectionIdentity_exports);
+var import_lodash_es = require("lodash-es");
+var IDENTITY_CONFIG = {
+  product: {
+    persistentIdField: "order_detail_id",
+    uidField: "unique_identification_number",
+    fallbackPrefix: "os-fallback:product:order-detail"
+  },
+  booking: {
+    persistentIdField: "schedule_event_id",
+    uidField: "unique_identification_number",
+    fallbackPrefix: "os-fallback:booking:schedule-event"
+  },
+  payment: {
+    persistentIdField: "order_payment_id",
+    uidField: "unique_payment_number",
+    fallbackPrefix: "os-fallback:payment:order-payment"
+  }
+};
+function createUuidV4() {
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  return template.replace(/[xy]/g, (char) => {
+    const randomValue = Math.floor(Math.random() * 16);
+    const value = char === "x" ? randomValue : randomValue & 3 | 8;
+    return value.toString(16);
+  });
+}
+function isBlankOrderCollectionIdentity(value) {
+  return value === void 0 || value === null || value === "";
+}
+function getOrderCollectionPersistentId(kind, item) {
+  const record = item;
+  if (!record)
+    return null;
+  const value = record[IDENTITY_CONFIG[kind].persistentIdField];
+  if (isBlankOrderCollectionIdentity(value))
+    return null;
+  return String(value);
+}
+function getOrderCollectionUid(kind, item) {
+  var _a;
+  const record = item;
+  if (!record)
+    return null;
+  const uidField = IDENTITY_CONFIG[kind].uidField;
+  const metadataValue = (_a = record.metadata) == null ? void 0 : _a[uidField];
+  if (!isBlankOrderCollectionIdentity(metadataValue))
+    return String(metadataValue);
+  const topLevelValue = record[uidField];
+  if (isBlankOrderCollectionIdentity(topLevelValue))
+    return null;
+  return String(topLevelValue);
+}
+function buildOrderCollectionFallbackUid(kind, persistentId) {
+  return `${IDENTITY_CONFIG[kind].fallbackPrefix}:${String(persistentId)}`;
+}
+function getOrderCollectionReferenceUid(kind, item) {
+  const uid = getOrderCollectionUid(kind, item);
+  if (uid)
+    return uid;
+  const persistentId = getOrderCollectionPersistentId(kind, item);
+  return persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : null;
+}
+function setOrderCollectionUid(kind, item, uid) {
+  const record = (0, import_lodash_es.cloneDeep)(item || {});
+  const uidField = IDENTITY_CONFIG[kind].uidField;
+  record.metadata = {
+    ...record.metadata && typeof record.metadata === "object" ? record.metadata : {},
+    [uidField]: uid
+  };
+  delete record[uidField];
+  return record;
+}
+function isSameOrderCollectionItem(kind, left, right) {
+  const leftPersistentId = getOrderCollectionPersistentId(kind, left);
+  const rightPersistentId = getOrderCollectionPersistentId(kind, right);
+  if (leftPersistentId && rightPersistentId) {
+    return leftPersistentId === rightPersistentId;
+  }
+  const leftUid = getOrderCollectionUid(kind, left);
+  const rightUid = getOrderCollectionUid(kind, right);
+  return Boolean(leftUid && rightUid && leftUid === rightUid);
+}
+function mergeOrderCollectionItems(kind, currentItem, incomingItem, options) {
+  var _a;
+  const current = (0, import_lodash_es.cloneDeep)(currentItem || {});
+  const incoming = (0, import_lodash_es.cloneDeep)(incomingItem || {});
+  const persistentIdField = IDENTITY_CONFIG[kind].persistentIdField;
+  const currentPersistentIdValue = current[persistentIdField];
+  const incomingPersistentIdValue = incoming[persistentIdField];
+  const incomingUid = getOrderCollectionUid(kind, incoming);
+  const currentUid = getOrderCollectionUid(kind, current);
+  const persistentId = getOrderCollectionPersistentId(kind, incoming) || getOrderCollectionPersistentId(kind, current);
+  const merged = {
+    ...current,
+    ...incoming,
+    metadata: {
+      ...current.metadata && typeof current.metadata === "object" ? current.metadata : {},
+      ...incoming.metadata && typeof incoming.metadata === "object" ? incoming.metadata : {}
+    }
+  };
+  if (!isBlankOrderCollectionIdentity(incomingPersistentIdValue)) {
+    merged[persistentIdField] = incomingPersistentIdValue;
+  } else if (!isBlankOrderCollectionIdentity(currentPersistentIdValue)) {
+    merged[persistentIdField] = currentPersistentIdValue;
+  }
+  const incomingUidIsDerived = Boolean(
+    incomingUid && persistentId && (incomingUid === buildOrderCollectionFallbackUid(kind, persistentId) || incomingUid.startsWith(`${buildOrderCollectionFallbackUid(kind, persistentId)}:conflict:`))
+  );
+  const uid = (incomingUid && !incomingUidIsDerived ? incomingUid : null) || currentUid || incomingUid || ((options == null ? void 0 : options.ensureUid) === false ? null : persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : ((_a = options == null ? void 0 : options.createAnonymousUid) == null ? void 0 : _a.call(options)) || createUuidV4());
+  return uid ? setOrderCollectionUid(kind, merged, uid) : merged;
+}
+function createEmptyIdentityStats() {
+  return {
+    backfilledUidCount: 0,
+    collapsedDuplicateCount: 0,
+    uidConflictCount: 0,
+    anonymousRowCount: 0
+  };
+}
+function allocateAnonymousUid(occupiedUids, createAnonymousUid) {
+  let uid = createAnonymousUid();
+  while (occupiedUids.has(uid))
+    uid = createAnonymousUid();
+  return uid;
+}
+function allocatePersistentConflictUid(kind, persistentId, occupiedUids) {
+  const fallbackUid = buildOrderCollectionFallbackUid(kind, persistentId);
+  if (!occupiedUids.has(fallbackUid))
+    return fallbackUid;
+  let suffix = 1;
+  let candidate = `${fallbackUid}:conflict:${suffix}`;
+  while (occupiedUids.has(candidate)) {
+    suffix += 1;
+    candidate = `${fallbackUid}:conflict:${suffix}`;
+  }
+  return candidate;
+}
+function normalizeOrderCollection(kind, items, options) {
+  var _a, _b;
+  const stats = createEmptyIdentityStats();
+  const uidRemaps = [];
+  const result = [];
+  const ensureUid = (options == null ? void 0 : options.ensureUid) !== false;
+  const createAnonymousUid = (options == null ? void 0 : options.createAnonymousUid) || createUuidV4;
+  for (const rawItem of items || []) {
+    const item = (0, import_lodash_es.cloneDeep)(rawItem);
+    const existingIndex = result.findIndex(
+      (existing) => isSameOrderCollectionItem(kind, existing, item)
+    );
+    if (existingIndex === -1) {
+      result.push(item);
+      continue;
+    }
+    const previousReferenceUid = getOrderCollectionReferenceUid(
+      kind,
+      result[existingIndex]
+    );
+    const incomingReferenceUid = getOrderCollectionReferenceUid(kind, item);
+    result[existingIndex] = mergeOrderCollectionItems(
+      kind,
+      result[existingIndex],
+      item,
+      { ensureUid: false }
+    );
+    const nextUid = getOrderCollectionUid(kind, result[existingIndex]);
+    if (nextUid) {
+      for (const from of /* @__PURE__ */ new Set([previousReferenceUid, incomingReferenceUid])) {
+        if (!from || from === nextUid)
+          continue;
+        uidRemaps.push({
+          kind,
+          from,
+          to: nextUid,
+          persistentId: getOrderCollectionPersistentId(kind, result[existingIndex])
+        });
+      }
+    }
+    stats.collapsedDuplicateCount += 1;
+  }
+  if (!ensureUid)
+    return { items: result, stats, uidRemaps };
+  const occupiedUids = /* @__PURE__ */ new Set();
+  for (let index = 0; index < result.length; index += 1) {
+    let item = result[index];
+    const persistentId = getOrderCollectionPersistentId(kind, item);
+    let uid = getOrderCollectionUid(kind, item);
+    if (!uid) {
+      uid = persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : allocateAnonymousUid(occupiedUids, createAnonymousUid);
+      item = setOrderCollectionUid(kind, item, uid);
+      result[index] = item;
+      stats.backfilledUidCount += 1;
+      if (!persistentId)
+        stats.anonymousRowCount += 1;
+    }
+    if (occupiedUids.has(uid)) {
+      const replacementUid = persistentId ? allocatePersistentConflictUid(kind, persistentId, occupiedUids) : allocateAnonymousUid(occupiedUids, createAnonymousUid);
+      result[index] = setOrderCollectionUid(kind, item, replacementUid);
+      uidRemaps.push({
+        kind,
+        from: uid,
+        to: replacementUid,
+        persistentId,
+        scope: "linked-owner",
+        referenceOwnerUid: kind === "product" ? String(
+          (item == null ? void 0 : item.booking_uid) || ((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a.booking_uid) || ""
+        ) || null : kind === "booking" ? String(
+          (item == null ? void 0 : item.product_uid) || ((_b = item == null ? void 0 : item.metadata) == null ? void 0 : _b.product_uid) || ""
+        ) || null : null
+      });
+      uid = replacementUid;
+      stats.uidConflictCount += 1;
+    }
+    occupiedUids.add(uid);
+  }
+  return { items: result, stats, uidRemaps };
+}
+function applyOrderCollectionUidRemaps(sourceOrder, uidRemaps) {
+  var _a, _b, _c, _d, _e;
+  if (!uidRemaps.length)
+    return sourceOrder;
+  const order = (0, import_lodash_es.cloneDeep)(sourceOrder);
+  const hasAmbiguousLinkedOwner = (remap) => {
+    if (remap.scope !== "linked-owner" || !remap.referenceOwnerUid)
+      return false;
+    const ownerKind = remap.kind === "product" ? "booking" : remap.kind === "booking" ? "product" : null;
+    if (!ownerKind)
+      return false;
+    return uidRemaps.some(
+      (candidate) => candidate.scope === "linked-owner" && candidate.kind === ownerKind && candidate.from === remap.referenceOwnerUid
+    );
+  };
+  for (const remap of uidRemaps) {
+    if (remap.from === remap.to)
+      continue;
+    const linkedOwnerIsAmbiguous = hasAmbiguousLinkedOwner(remap);
+    if (remap.kind === "product") {
+      for (const booking of order.bookings || []) {
+        if (remap.scope === "linked-owner" && (linkedOwnerIsAmbiguous || getOrderCollectionUid("booking", booking) !== remap.referenceOwnerUid)) {
+          continue;
+        }
+        if (String((booking == null ? void 0 : booking.product_uid) || "") === remap.from) {
+          booking.product_uid = remap.to;
+        }
+        if (String(((_a = booking == null ? void 0 : booking.metadata) == null ? void 0 : _a.product_uid) || "") === remap.from) {
+          booking.metadata = { ...booking.metadata || {}, product_uid: remap.to };
+        }
+      }
+      if (remap.scope !== "linked-owner") {
+        for (const product of order.products || []) {
+          if (String(((_b = product == null ? void 0 : product.metadata) == null ? void 0 : _b.parent_unique_identification_number) || "") === remap.from) {
+            product.metadata = {
+              ...product.metadata || {},
+              parent_unique_identification_number: remap.to
+            };
+          }
+          const giftInfo = (_c = product == null ? void 0 : product.metadata) == null ? void 0 : _c._giftInfo;
+          if (giftInfo && typeof giftInfo === "object") {
+            const sourceProductIds = Array.isArray(giftInfo.sourceProductIds) ? giftInfo.sourceProductIds.map(
+              (uid) => String(uid) === remap.from ? remap.to : uid
+            ) : giftInfo.sourceProductIds;
+            const sourceProductId = String(giftInfo.sourceProductId || "") === remap.from ? remap.to : giftInfo.sourceProductId;
+            product.metadata = {
+              ...product.metadata || {},
+              _giftInfo: {
+                ...giftInfo,
+                ...sourceProductIds !== void 0 ? { sourceProductIds } : {},
+                ...sourceProductId !== void 0 ? { sourceProductId } : {}
+              }
+            };
+          }
+        }
+      }
+      const productsByUid = (_d = order._extend) == null ? void 0 : _d.productsByUid;
+      const cachedProduct = productsByUid == null ? void 0 : productsByUid[remap.from];
+      const cachedPersistentId = getOrderCollectionPersistentId(
+        "product",
+        (cachedProduct == null ? void 0 : cachedProduct.origin) || cachedProduct
+      );
+      if (productsByUid && remap.scope === "linked-owner") {
+        const retainedProduct = (order.products || []).find(
+          (product) => getOrderCollectionUid("product", product) === remap.from
+        );
+        const remappedProduct = (order.products || []).find(
+          (product) => getOrderCollectionUid("product", product) === remap.to
+        );
+        if (cachedProduct && remap.persistentId && cachedPersistentId === remap.persistentId) {
+          productsByUid[remap.to] = {
+            ...cachedProduct || {},
+            ...productsByUid[remap.to] || {}
+          };
+          if (retainedProduct) {
+            productsByUid[remap.from] = {
+              ...cachedProduct || {},
+              origin: (0, import_lodash_es.cloneDeep)(retainedProduct)
+            };
+          }
+        } else if (remappedProduct && !productsByUid[remap.to]) {
+          productsByUid[remap.to] = { origin: (0, import_lodash_es.cloneDeep)(remappedProduct) };
+        }
+        continue;
+      }
+      if (cachedProduct && remap.scope !== "linked-owner") {
+        productsByUid[remap.to] = {
+          ...cachedProduct || {},
+          ...productsByUid[remap.to] || {}
+        };
+        delete productsByUid[remap.from];
+      }
+    }
+    if (remap.kind === "booking") {
+      for (const product of order.products || []) {
+        if (remap.scope === "linked-owner" && (linkedOwnerIsAmbiguous || getOrderCollectionUid("product", product) !== remap.referenceOwnerUid)) {
+          continue;
+        }
+        if (String((product == null ? void 0 : product.booking_uid) || "") === remap.from) {
+          product.booking_uid = remap.to;
+        }
+        if (String(((_e = product == null ? void 0 : product.metadata) == null ? void 0 : _e.booking_uid) || "") === remap.from) {
+          product.metadata = { ...product.metadata || {}, booking_uid: remap.to };
+        }
+      }
+    }
+  }
+  return order;
+}
+function normalizeOrderCollections(sourceOrder, options) {
+  let order = (0, import_lodash_es.cloneDeep)(sourceOrder || {});
+  const orderRecord = order;
+  const productResult = normalizeOrderCollection(
+    "product",
+    Array.isArray(orderRecord.products) ? orderRecord.products : [],
+    options
+  );
+  const bookingResult = normalizeOrderCollection(
+    "booking",
+    Array.isArray(orderRecord.bookings) ? orderRecord.bookings : [],
+    options
+  );
+  const paymentResult = normalizeOrderCollection(
+    "payment",
+    Array.isArray(orderRecord.payments) ? orderRecord.payments : [],
+    options
+  );
+  if (Array.isArray(orderRecord.products))
+    orderRecord.products = productResult.items;
+  if (Array.isArray(orderRecord.bookings))
+    orderRecord.bookings = bookingResult.items;
+  if (Array.isArray(orderRecord.payments))
+    orderRecord.payments = paymentResult.items;
+  const uidRemaps = [
+    ...productResult.uidRemaps,
+    ...bookingResult.uidRemaps,
+    ...paymentResult.uidRemaps
+  ];
+  order = applyOrderCollectionUidRemaps(order, uidRemaps);
+  return {
+    order,
+    stats: {
+      product: productResult.stats,
+      booking: bookingResult.stats,
+      payment: paymentResult.stats
+    },
+    uidRemaps
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyOrderCollectionUidRemaps,
+  buildOrderCollectionFallbackUid,
+  createUuidV4,
+  getOrderCollectionPersistentId,
+  getOrderCollectionReferenceUid,
+  getOrderCollectionUid,
+  isBlankOrderCollectionIdentity,
+  isSameOrderCollectionItem,
+  mergeOrderCollectionItems,
+  normalizeOrderCollection,
+  normalizeOrderCollections,
+  setOrderCollectionUid
+});

package/lib/modules/Order/utils.d.ts

@@ -3,6 +3,7 @@ import type { CartItem } from "../Cart";
 import type { OrderProductDiscountItem, OrderProduct, OrderSubmitPayload, OrderSubmitProduct, OrderSummary, OrderTempOrder } from './types';
 import type { RulesParamsHooks } from '../Rules/types';
 import type { MapOrderPaymentsOptions, OrderPaymentData, OrderPaymentSource } from './types';
+import { createUuidV4 } from './utils/orderCollectionIdentity';
 export interface OrderProductsDepositProtocol {
     id: number;
     title: string;
@@ -67,8 +68,8 @@ export declare function sumOptionUnitPrice(options?: Array<{
 /**
  * 仅基于 tempOrder.products 重算整单定金。
  *
- * 对齐 Checkout relation_products 分支：商品定金先按商品规则计算，
- * 再扣减商品券/折扣卡抵扣金额；tempOrder.bookings 不参与这里的计算。
+ * 商品折扣在进入定金计算前已体现在商品行价格字段中，
+ * 因此这里只按商品定金规则汇总，不再扣减 discount_list；tempOrder.bookings 不参与这里的计算。
  */
 export declare function calculateOrderProductsDeposit(products?: OrderProduct[], options?: {
     productsByUid?: Record<string, Record<string, any>>;
@@ -177,7 +178,7 @@ export declare const mergeRelationForms: (relationForms: {
     form_record_ids: number[];
 }[];
 export declare const getAllDiscountList: (cartItem: CartItem) => any;
-export declare function createUuidV4(): string;
+export { createUuidV4 };
 export declare function isTempOrder(data: any): data is OrderTempOrder;
 export declare function formatDateTime(date: Date): string;
 export declare function normalizeBookingIsAll(booking: Record<string, any>): 0 | 1;

package/lib/modules/Order/utils.js

@@ -37,7 +37,7 @@ __export(utils_exports, {
   createDefaultOrderRulesHooks: () => createDefaultOrderRulesHooks,
   createDefaultTempOrder: () => createDefaultTempOrder,
   createEmptySummary: () => import_utils2.createEmptySummary,
-  createUuidV4: () => createUuidV4,
+  createUuidV4: () => import_orderCollectionIdentity.createUuidV4,
   ensureManualProductDiscountList: () => import_manualProductDiscount.ensureManualProductDiscountList,
   ensureProductSku: () => ensureProductSku,
   findManualProductDiscountItem: () => import_manualProductDiscount.findManualProductDiscountItem,
@@ -86,6 +86,7 @@ module.exports = __toCommonJS(utils_exports);
 var import_dayjs = __toESM(require("dayjs"));
 var import_decimal = __toESM(require("decimal.js"));
 var import_utils = require("../../solution/ScanOrder/utils");
+var import_orderCollectionIdentity = require("./utils/orderCollectionIdentity");
 var import_utils2 = require("../../solution/ScanOrder/utils");
 var import_manualProductDiscount = require("./utils/manualProductDiscount");
 function composeLinePrice(params) {
@@ -286,9 +287,6 @@ function calculateOrderProductsDeposit(products = [], options) {
     if (!(deposit == null ? void 0 : deposit.total) || Number(deposit.total) <= 0)
       continue;
     total = total.plus(deposit.total);
-    for (const discount of product.discount_list || []) {
-      total = total.minus((discount == null ? void 0 : discount.amount) || 0);
-    }
     for (const protocol of deposit.protocols || []) {
       if (!protocolMap.has(protocol.id))
         protocolMap.set(protocol.id, protocol);
@@ -446,12 +444,7 @@ function resolveEffectivePerUnitDiscount(product) {
     (sum, discount) => sum + Number((discount == null ? void 0 : discount.amount) || 0),
     0
   );
-  const hasPromoDiscountItem = discountList.some(
-    (item) => {
-      var _a, _b;
-      return (item == null ? void 0 : item.type) === "promotion" || (item == null ? void 0 : item.type) === "product" && ((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a.source) === "promotion" && ((_b = item == null ? void 0 : item.metadata) == null ? void 0 : _b.actionType) === "ITEM_REWARD";
-    }
-  );
+  const hasPromoDiscountItem = discountList.some((item) => (item == null ? void 0 : item.type) === "promotion");
   if (hasPromoDiscountItem)
     return fromList;
   const metadata = (product == null ? void 0 : product.metadata) || {};
@@ -500,13 +493,17 @@ function createDefaultOrderRulesHooks() {
       const current = currentByIdentity.get(getBundleIdentity(bundle));
       if (!current)
         return bundle;
+      const bundleWithDisplayFields = {
+        ...bundle,
+        ...isEmptyOrderProductDisplayValue(bundle.cover) && !isEmptyOrderProductDisplayValue(current.cover) ? { cover: current.cover } : {}
+      };
       const isProductPriceBundle = (bundle.price_type_ext ?? current.price_type_ext) === "product_price";
       if (!isProductPriceBundle)
-        return bundle;
+        return bundleWithDisplayFields;
       const sourcePrice = current.price ?? current.custom_price ?? current.original_price ?? current.bundle_selling_price;
       const originalPrice = current.original_price ?? current.product_price ?? current.price ?? current.custom_price ?? sourcePrice;
       return {
-        ...bundle,
+        ...bundleWithDisplayFields,
         ...sourcePrice !== void 0 ? { price: sourcePrice } : {},
         ...originalPrice !== void 0 ? { original_price: originalPrice } : {},
         ...current.original_total !== void 0 ? { original_total: current.original_total } : {}
@@ -645,14 +642,6 @@ var getAllDiscountList = (cartItem) => {
   });
   return discountList;
 };
-function createUuidV4() {
-  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
-  return template.replace(/[xy]/g, (char) => {
-    const randomValue = Math.floor(Math.random() * 16);
-    const value = char === "x" ? randomValue : randomValue & 3 | 8;
-    return value.toString(16);
-  });
-}
 function isTempOrder(data) {
   if (!data || typeof data !== "object")
     return false;
@@ -750,6 +739,7 @@ function formatSubmitBundleItems(bundle) {
       bundle_group_id: (rawBundle == null ? void 0 : rawBundle.bundle_group_id) ?? (rawBundle == null ? void 0 : rawBundle.group_id),
       bundle_id: (rawBundle == null ? void 0 : rawBundle.bundle_id) ?? (rawBundle == null ? void 0 : rawBundle.id),
       bundle_product_id: (rawBundle == null ? void 0 : rawBundle.bundle_product_id) ?? (rawBundle == null ? void 0 : rawBundle._bundle_product_id),
+      cover: rawBundle.cover,
       metadata: {
         ...submitMetadata,
         ...hasSubmitBundleDiscounts && bundleMapId !== void 0 ? { custom_product_bundle_map_id: bundleMapId } : {},
@@ -808,6 +798,9 @@ function normalizeSubmitProduct(product) {
   if (rawMetadata.is_rule !== void 0) {
     cleanMetadata.is_rule = rawMetadata.is_rule;
   }
+  if (rawMetadata.holder_config !== void 0) {
+    cleanMetadata.holder_config = rawMetadata.holder_config;
+  }
   const productSku = {
     ...submitProduct.product_sku && typeof submitProduct.product_sku === "object" ? submitProduct.product_sku : {},
     option: formatSubmitOptionItems((_a = submitProduct.product_sku) == null ? void 0 : _a.option)
@@ -938,7 +931,7 @@ function buildSubmitPayload(params) {
     enhance
   } = params;
   const scheduleDate = tempOrder.schedule_date || tempOrder.created_at || formatDateTime(now);
-  const bookingUuid = createUuidV4();
+  const bookingUuid = (0, import_orderCollectionIdentity.createUuidV4)();
   const {
     _extend,
     relation_id: _relationId,
@@ -1086,7 +1079,7 @@ function formatV1Product(products) {
       note: String(product.note ?? ""),
       rowKey: product.product_id,
       session: null,
-      unique: createUuidV4()
+      unique: (0, import_orderCollectionIdentity.createUuidV4)()
     };
   });
 }
@@ -1164,11 +1157,16 @@ function isHolderConfigRequired(holderConfig) {
   return Number(holderConfig.required) === 1;
 }
 function productRequiresFormSubject(tempOrder, product) {
+  var _a, _b;
+  const _orderProduct = (_a = tempOrder == null ? void 0 : tempOrder.products) == null ? void 0 : _a.find((item) => {
+    return item.metadata.unique_identification_number === product._id || item.product_id === product.id;
+  });
   const runtimeOrigin = getRuntimeProductOrigin(tempOrder, product);
-  return isHolderConfigRequired(product == null ? void 0 : product.holder_config) || isHolderConfigRequired(runtimeOrigin == null ? void 0 : runtimeOrigin.holder_config);
+  return isHolderConfigRequired((_b = _orderProduct == null ? void 0 : _orderProduct.metadata) == null ? void 0 : _b.holder_config) || isHolderConfigRequired(runtimeOrigin == null ? void 0 : runtimeOrigin.holder_config) || isHolderConfigRequired(product == null ? void 0 : product.holder_config);
 }
 function resolveIsFormSubject(tempOrder, product) {
   var _a;
+  debugger;
   if (((_a = tempOrder == null ? void 0 : tempOrder.holder) == null ? void 0 : _a.type) === "form")
     return true;
   if (product)
@@ -1197,6 +1195,7 @@ function mergeOrderProductDisplayFields(previous, next) {
     "product_name",
     "product_cover",
     "cover",
+    "product_cover",
     "variant_title",
     "product_sku",
     "payment_price"