@pisell/pisellos 2.2.215 → 2.2.217

package/lib/server/modules/order/index.js

@@ -181,6 +181,18 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     } catch {
     }
   }
+  logWarning(title, metadata) {
+    try {
+      if (this.logger) {
+        this.logger.addLog({
+          type: "warning",
+          title: `[OrderServerModule] ${title}`,
+          metadata: metadata || {}
+        });
+      }
+    } catch {
+    }
+  }
   /**
    * 记录订单最近一次 SQLite 写入，供 pubsub 回声去重使用。
    *
@@ -586,33 +598,28 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.logInfo("upsertPendingSyncOrders-开始", { count: pendingMap.size });
     const patchedOrders = [...pendingMap.values()];
     const mergeActions = {};
-    const updatedList = this.store.list.map((order) => {
-      const storageKey = this.getOrderStorageKey(order);
-      if (!storageKey || !pendingMap.has(storageKey))
-        return order;
-      const pendingOrder = memoryPendingMap.get(storageKey);
+    const updatedList = [...this.store.list];
+    for (const [storageKey, pendingOrder] of memoryPendingMap.entries()) {
+      const matchIndex = this.findOrderIndexByIdentity(updatedList, pendingOrder);
+      if (matchIndex < 0)
+        continue;
+      updatedList[matchIndex] = this.mergeOrderRecords(updatedList[matchIndex], pendingOrder);
       pendingMap.delete(storageKey);
       memoryPendingMap.delete(storageKey);
       mergeActions[storageKey] = "update";
-      return pendingOrder;
-    });
+    }
     for (const [storageKey, order] of memoryPendingMap.entries()) {
       mergeActions[storageKey] = "insert";
       updatedList.push(order);
     }
-    this.store.list = updatedList;
+    this.store.list = this.compactOrderListByIdentity(updatedList, "upsertPendingSyncOrders.store").list;
     this.syncOrdersMap();
     await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
     this.logInfo("upsertPendingSyncOrders-结束", {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
-    this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
-    await this.core.effects.emit(import_types.OrderHooks.onOrdersChanged, {
-      list: this.store.list,
-      changedOrders: patchedOrders.map((order) => this.normalizeOrderForMemoryList(order)),
-      source: "upsertPendingSyncOrders"
-    });
+    await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
   }
   /**
    * 通过 SSE 按自定义 query 拉取订单（支持 select/with 精简字段）
@@ -649,14 +656,11 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.store.map.clear();
     this.resourceIdIndex.clear();
     for (const order of this.store.list) {
-      const identityKeys = this.getOrderIdentityKeys(order);
-      if (identityKeys.length === 0)
+      const primaryIdentity = this.getOrderMapKey(order);
+      if (!primaryIdentity)
         continue;
-      for (const identityKey of identityKeys) {
-        this.store.map.set(identityKey, order);
-      }
+      this.store.map.set(primaryIdentity, order);
       const resourceIds = this.extractResourceIds(order);
-      const primaryIdentity = identityKeys[0];
       for (const resourceId of resourceIds) {
         const key = String(resourceId);
         const existing = this.resourceIdIndex.get(key) || [];
@@ -667,17 +671,48 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
     }
   }
+  getOrderMapKey(order) {
+    if (!order)
+      return "";
+    if (!this.isBlankIdentityValue(order.order_id)) {
+      return this.getIdKey(order.order_id);
+    }
+    const externalSaleNumber = order.external_sale_number;
+    if (!this.isBlankIdentityValue(externalSaleNumber)) {
+      return this.getIdKey(externalSaleNumber);
+    }
+    return "";
+  }
+  isBlankIdentityValue(value) {
+    return value === void 0 || value === null || value === "";
+  }
+  getOrderIdentityEntries(order) {
+    if (!order)
+      return [];
+    const record = order;
+    const candidates = [
+      { field: "order_id", value: order.order_id },
+      { field: "external_sale_number", value: record.external_sale_number },
+      { field: "order_number", value: record.order_number },
+      { field: "shop_order_number", value: record.shop_order_number },
+      { field: "shop_full_order_number", value: record.shop_full_order_number }
+    ];
+    const entries = [];
+    for (const candidate of candidates) {
+      if (this.isBlankIdentityValue(candidate.value))
+        continue;
+      const key = this.getIdKey(candidate.value);
+      if (entries.some((entry) => entry.field === candidate.field && entry.key === key))
+        continue;
+      entries.push({ field: candidate.field, key });
+    }
+    return entries;
+  }
   getOrderIdentityKeys(order) {
     const keys = [];
-    const id = order.order_id;
-    if (id !== void 0 && id !== null && id !== "") {
-      keys.push(this.getIdKey(id));
-    }
-    const externalSaleNumber = order == null ? void 0 : order.external_sale_number;
-    if (externalSaleNumber !== void 0 && externalSaleNumber !== null && externalSaleNumber !== "") {
-      const externalKey = this.getIdKey(externalSaleNumber);
-      if (!keys.includes(externalKey))
-        keys.push(externalKey);
+    for (const entry of this.getOrderIdentityEntries(order)) {
+      if (!keys.includes(entry.key))
+        keys.push(entry.key);
     }
     return keys;
   }
@@ -920,65 +955,51 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       freshOrderCount: freshOrders.length,
       storeOrderCountBefore: this.store.list.length
     });
-    const freshMap = /* @__PURE__ */ new Map();
+    this.logDuplicateOrders(`${source}.beforeMerge`, this.store.list);
+    const normalizedFreshOrders = [];
     for (const order of freshOrders) {
       const id = order == null ? void 0 : order.order_id;
       if (id === void 0 || id === null)
         continue;
-      freshMap.set(this.getIdKey(id), this.normalizeRemoteSyncedOrder(order));
+      normalizedFreshOrders.push(this.normalizeRemoteSyncedOrder(order));
     }
-    const freshStorageKeyMap = /* @__PURE__ */ new Map();
-    for (const order of freshMap.values()) {
-      const storageKey = this.getOrderStorageKey(order);
-      if (!storageKey)
-        continue;
-      freshStorageKeyMap.set(storageKey, order);
-    }
-    const uniqueFreshCount = freshMap.size;
-    const patchedOrders = [...freshMap.values()];
+    const uniqueFreshOrders = this.compactOrderListByIdentity(
+      normalizedFreshOrders,
+      `${source}.incoming`
+    ).list;
+    const uniqueFreshCount = uniqueFreshOrders.length;
+    const patchedOrders = [];
     const mergeActions = {};
-    const updatedList = this.store.list.map((order) => {
-      const storageKey = this.getOrderStorageKey(order);
-      if (storageKey && freshStorageKeyMap.has(storageKey)) {
-        const fresh2 = freshStorageKeyMap.get(storageKey);
-        freshStorageKeyMap.delete(storageKey);
-        const freshId = fresh2.order_id;
-        if (freshId !== void 0 && freshId !== null) {
-          freshMap.delete(this.getIdKey(freshId));
-          mergeActions[this.getIdKey(freshId)] = "update";
-        } else {
-          mergeActions[storageKey] = "update";
-        }
-        return fresh2;
-      }
-      const id = order.order_id;
-      if (id === void 0 || id === null)
-        return order;
-      const key = this.getIdKey(id);
-      if (!freshMap.has(key))
-        return order;
-      const fresh = freshMap.get(key);
-      freshMap.delete(key);
-      mergeActions[key] = "update";
-      return fresh;
-    });
-    for (const order of freshMap.values()) {
-      const id = order.order_id;
-      if (id !== void 0 && id !== null) {
-        mergeActions[this.getIdKey(id)] = "insert";
+    const updatedList = [...this.store.list];
+    for (const fresh of uniqueFreshOrders) {
+      const matchIndex = this.findOrderIndexByIdentity(updatedList, fresh);
+      const storageKey = this.getOrderStorageKey(fresh);
+      const mergeKey = storageKey || (fresh.order_id !== void 0 && fresh.order_id !== null ? this.getIdKey(fresh.order_id) : "");
+      if (matchIndex >= 0) {
+        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], fresh);
+        updatedList[matchIndex] = mergedOrder;
+        patchedOrders.push(mergedOrder);
+        if (mergeKey)
+          mergeActions[mergeKey] = "update";
+        continue;
       }
-      updatedList.push(order);
+      updatedList.push(fresh);
+      patchedOrders.push(fresh);
+      if (mergeKey)
+        mergeActions[mergeKey] = "insert";
     }
     const insertCount = Object.values(mergeActions).filter((v) => v === "insert").length;
     const updateCount = Object.values(mergeActions).filter((v) => v === "update").length;
-    this.store.list = updatedList;
+    this.store.list = this.compactOrderListByIdentity(updatedList, `${source}.store`).list;
     this.syncOrdersMap();
     await this.patchOrdersInSQLite(patchedOrders, source, mergeActions);
     this.logInfo("mergeOrdersToStore-结束", {
       uniqueFreshCount,
-      storeOrderCountAfter: this.store.list.length
+      storeOrderCountAfter: this.store.list.length,
+      insertCount,
+      updateCount
     });
-    this.emitOrdersChanged(patchedOrders, source);
+    await this.emitOrdersChanged(patchedOrders, source);
   }
   normalizeOrderSyncMessage(res) {
     const data = (res == null ? void 0 : res.data) || res;
@@ -1057,6 +1078,129 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
     return "";
   }
+  getOrderIdentityMatchKeys(order) {
+    return this.getOrderIdentityEntries(order).map((entry) => `${entry.field}:${entry.key}`);
+  }
+  doOrdersShareIdentity(left, right) {
+    const leftKeys = new Set(this.getOrderIdentityMatchKeys(left));
+    if (leftKeys.size === 0)
+      return false;
+    return this.getOrderIdentityMatchKeys(right).some((key) => leftKeys.has(key));
+  }
+  findOrderIndexByIdentity(orders, target) {
+    if (this.getOrderIdentityMatchKeys(target).length === 0)
+      return -1;
+    return orders.findIndex((order) => this.doOrdersShareIdentity(order, target));
+  }
+  getOrderCompletenessScore(order) {
+    const record = order;
+    let score = this.isPendingSyncOrder(order) ? 0 : 100;
+    if (!this.isBlankIdentityValue(order.order_id) && order.order_id !== record.external_sale_number)
+      score += 30;
+    score += this.getOrderIdentityMatchKeys(order).length * 5;
+    if (Array.isArray(order.products))
+      score += Math.min(order.products.length, 10);
+    if (Array.isArray(order.bookings))
+      score += Math.min(order.bookings.length, 10);
+    if (Array.isArray(order.payments))
+      score += Math.min(order.payments.length, 10);
+    if (record.updated_at)
+      score += 1;
+    return score;
+  }
+  pickPreferredOrder(left, right) {
+    const leftScore = this.getOrderCompletenessScore(left);
+    const rightScore = this.getOrderCompletenessScore(right);
+    if (rightScore >= leftScore)
+      return right;
+    return left;
+  }
+  mergeOrderRecords(existing, incoming) {
+    const preferred = this.pickPreferredOrder(existing, incoming);
+    const secondary = preferred === existing ? incoming : existing;
+    const merged = {
+      ...secondary,
+      ...preferred
+    };
+    const fieldsToPreserve = [
+      "order_id",
+      "external_sale_number",
+      "order_number",
+      "shop_order_number",
+      "shop_full_order_number"
+    ];
+    const mergedRecord = merged;
+    const preferredRecord = preferred;
+    const secondaryRecord = secondary;
+    for (const field of fieldsToPreserve) {
+      if (!this.isBlankIdentityValue(preferredRecord[field])) {
+        mergedRecord[field] = preferredRecord[field];
+        continue;
+      }
+      if (!this.isBlankIdentityValue(secondaryRecord[field])) {
+        mergedRecord[field] = secondaryRecord[field];
+      }
+    }
+    if (!this.isPendingSyncOrder(preferred) || !this.isPendingSyncOrder(secondary)) {
+      merged.need_sync = 0;
+    }
+    return merged;
+  }
+  summarizeDuplicateOrders(orders) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const order of orders) {
+      for (const key of this.getOrderIdentityMatchKeys(order)) {
+        const group = groups.get(key) || [];
+        group.push(order);
+        groups.set(key, group);
+      }
+    }
+    return [...groups.entries()].filter(([, group]) => group.length > 1).slice(0, 20).map(([key, group]) => ({
+      key,
+      count: group.length,
+      orders: group.map((order) => ({
+        order_id: order.order_id ?? null,
+        external_sale_number: order.external_sale_number ?? null,
+        shop_order_number: order.shop_order_number ?? null,
+        shop_full_order_number: order.shop_full_order_number ?? null,
+        need_sync: order.need_sync ?? null
+      }))
+    }));
+  }
+  logDuplicateOrders(source, orders) {
+    const duplicateGroups = this.summarizeDuplicateOrders(orders);
+    if (duplicateGroups.length === 0)
+      return;
+    this.logWarning("检测到重复订单身份键", {
+      source,
+      duplicateGroupCount: duplicateGroups.length,
+      duplicateGroups
+    });
+  }
+  compactOrderListByIdentity(orders, source) {
+    const list = [];
+    let removedCount = 0;
+    for (const order of orders) {
+      const matchIndex = this.findOrderIndexByIdentity(list, order);
+      if (matchIndex < 0) {
+        list.push(order);
+        continue;
+      }
+      list[matchIndex] = this.mergeOrderRecords(list[matchIndex], order);
+      removedCount += 1;
+    }
+    if (removedCount > 0) {
+      this.logWarning("订单列表重复项已压缩", {
+        source,
+        beforeCount: orders.length,
+        afterCount: list.length,
+        removedCount
+      });
+    } else {
+      this.logDuplicateOrders(source, orders);
+    }
+    return { list, removedCount };
+  }
   /**
    * 当前订单拉取窗口：
    * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
@@ -1140,19 +1284,19 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   }
   mergeRemoteSnapshotWithPendingOrders(remoteOrders, existingOrders) {
     const merged = remoteOrders.map((order) => this.normalizeRemoteSyncedOrder(order));
-    const remoteStorageKeys = new Set(
-      merged.map((order) => this.getOrderStorageKey(order)).filter(Boolean)
-    );
     for (const order of existingOrders) {
       if (!this.isPendingSyncOrder(order))
         continue;
-      const storageKey = this.getOrderStorageKey(order);
-      if (!storageKey || remoteStorageKeys.has(storageKey))
+      const matchIndex = this.findOrderIndexByIdentity(merged, order);
+      if (matchIndex >= 0) {
+        merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
+        continue;
+      }
+      if (!this.getOrderStorageKey(order))
         continue;
       merged.push(order);
-      remoteStorageKeys.add(storageKey);
     }
-    return merged;
+    return this.compactOrderListByIdentity(merged, "mergeRemoteSnapshotWithPendingOrders").list;
   }
   /**
    * 串行执行订单 SQLite 写入任务，避免快照替换与增量 upsert 并发交错。
@@ -1189,30 +1333,34 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     if (toWrite.length === 0) {
       return;
     }
+    const compactedToWrite = this.compactOrderListByIdentity(toWrite, `${source}.sqlitePatch`).list;
+    if (compactedToWrite.length === 0) {
+      return;
+    }
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         let writeMethod = "none";
         this.logInfo("patchOrdersInSQLite-开始", {
           source,
-          count: toWrite.length,
+          count: compactedToWrite.length,
           dedupedCount: skipped.length
         });
         if (typeof this.dbManager.bulkUpdate === "function") {
           writeMethod = "bulkUpdate";
-          await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, toWrite);
+          await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, compactedToWrite);
         } else if (typeof this.dbManager.bulkAdd === "function") {
           writeMethod = "bulkAdd";
-          await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, toWrite);
+          await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, compactedToWrite);
         } else if (typeof this.dbManager.update === "function") {
           writeMethod = "update";
-          for (const order of toWrite) {
+          for (const order of compactedToWrite) {
             await this.dbManager.update(INDEXDB_STORE_NAME, order);
           }
         }
-        this.recordRecentSqliteWrite(source, toWrite);
+        this.recordRecentSqliteWrite(source, compactedToWrite);
         this.logInfo("patchOrdersInSQLite-完成", {
           source,
-          count: toWrite.length,
+          count: compactedToWrite.length,
           writeMethod,
           dedupedCount: skipped.length
         });
@@ -1275,10 +1423,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    */
   async replaceOrdersSnapshotInSQLite(orderList, source) {
     if (!this.dbManager) {
-      return orderList.map((order) => this.normalizeRemoteSyncedOrder(order));
+      return this.compactOrderListByIdentity(
+        orderList.map((order) => this.normalizeRemoteSyncedOrder(order)),
+        `${source}.snapshotNoDb`
+      ).list;
     }
     const remoteSnapshot = (0, import_lodash_es.cloneDeep)(orderList);
-    let mergedSnapshot = remoteSnapshot.map((order) => this.normalizeRemoteSyncedOrder(order));
+    let mergedSnapshot = this.compactOrderListByIdentity(
+      remoteSnapshot.map((order) => this.normalizeRemoteSyncedOrder(order)),
+      `${source}.remoteSnapshot`
+    ).list;
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         const existingOrders = typeof this.dbManager.getAll === "function" ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
@@ -1286,25 +1440,25 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           remoteSnapshot,
           existingOrders || []
         );
-        mergedSnapshot = orderListSnapshot;
+        mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
         this.logInfo("replaceOrdersSnapshotInSQLite-开始", {
           source,
-          count: orderListSnapshot.length,
+          count: mergedSnapshot.length,
           remoteCount: remoteSnapshot.length,
-          preservedPendingCount: orderListSnapshot.length - remoteSnapshot.length
+          preservedPendingCount: mergedSnapshot.length - remoteSnapshot.length
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);
         this.logInfo("replaceOrdersSnapshotInSQLite-clear完成", {
-          count: orderListSnapshot.length
+          count: mergedSnapshot.length
         });
-        if (orderListSnapshot.length === 0) {
+        if (mergedSnapshot.length === 0) {
           return;
         }
-        await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, orderListSnapshot);
-        this.recordRecentSqliteWrite(source, orderListSnapshot);
+        await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, mergedSnapshot);
+        this.recordRecentSqliteWrite(source, mergedSnapshot);
         this.logInfo("replaceOrdersSnapshotInSQLite-bulkAdd完成", {
           source,
-          count: orderListSnapshot.length
+          count: mergedSnapshot.length
         });
       });
     } catch (error) {

package/lib/solution/BaseSales/index.js

@@ -70,14 +70,54 @@ function preserveManualProductDiscountProducts(previousProducts, nextProducts) {
     return previous && isBaseSalesManualProductDiscountProduct(previous) ? previous : product;
   });
 }
+function getBaseSalesUniqueArrayMetadataKey(key) {
+  if (key === "products" || key === "bookings")
+    return "unique_identification_number";
+  if (key === "payments" || key === "payment")
+    return "unique_payment_number";
+  return null;
+}
+function getBaseSalesMetadataUid(item, metadataKey) {
+  var _a;
+  const uid = ((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a[metadataKey]) ?? (item == null ? void 0 : item[metadataKey]);
+  if (uid === void 0 || uid === null || uid === "")
+    return null;
+  return String(uid);
+}
+function mergeBaseSalesUniqueArray(currentValue, loadedValue, metadataKey) {
+  const result = [];
+  const indexByUid = /* @__PURE__ */ new Map();
+  const appendOrReplaceByUid = (item) => {
+    const clonedItem = (0, import_lodash_es.cloneDeep)(item);
+    const uid = getBaseSalesMetadataUid(clonedItem, metadataKey);
+    if (!uid) {
+      result.push(clonedItem);
+      return;
+    }
+    const existingIndex = indexByUid.get(uid);
+    if (existingIndex !== void 0) {
+      result[existingIndex] = clonedItem;
+      return;
+    }
+    indexByUid.set(uid, result.length);
+    result.push(clonedItem);
+  };
+  currentValue.forEach(appendOrReplaceByUid);
+  loadedValue.forEach(appendOrReplaceByUid);
+  return result;
+}
 function mergeSalesDetailRecordWithTempOrder(currentTempOrder, loadedRecord) {
   if (!currentTempOrder)
     return loadedRecord;
   return (0, import_lodash_es.mergeWith)(
     (0, import_lodash_es.cloneDeep)(currentTempOrder),
     (0, import_lodash_es.cloneDeep)(loadedRecord || {}),
-    (currentValue, loadedValue) => {
+    (currentValue, loadedValue, key) => {
       if (Array.isArray(currentValue) && Array.isArray(loadedValue)) {
+        const metadataKey = getBaseSalesUniqueArrayMetadataKey(key);
+        if (metadataKey) {
+          return mergeBaseSalesUniqueArray(currentValue, loadedValue, metadataKey);
+        }
         return [
           ...(0, import_lodash_es.cloneDeep)(currentValue),
           ...(0, import_lodash_es.cloneDeep)(loadedValue)
@@ -1205,7 +1245,6 @@ var BaseSalesImpl = class extends import_BaseModule.BaseModule {
     if (!this.store.order) {
       throw new Error("BaseSales 解决方案需要 order 模块支持");
     }
-    this.store.order.persistTempOrder();
     const inferredPaymentStatus = this.getSubmitPaymentStatus(params == null ? void 0 : params.paymentStatus);
     const submitParams = {
       cacheId: this.cacheId,

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

@@ -311,7 +311,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 1 | 2 | 3 | 5 | 4 | 6;
+        weekNum: 0 | 2 | 1 | 6 | 3 | 4 | 5;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/lib/solution/BookingTicket/index.js

@@ -267,7 +267,6 @@ var BookingTicketImpl = class extends import_BaseSales.BaseSalesImpl {
       };
       customerModule.setSelectedCustomer(customer);
       this.setOrderCustomer(customer);
-      await this.store.order.saveDraft();
     }
     return sales;
   }
@@ -477,7 +476,8 @@ var BookingTicketImpl = class extends import_BaseSales.BaseSalesImpl {
       throw new Error("refreshSalesDetail: tempOrder.order_id 缺失");
     }
     return this.loadSalesDetail({
-      orderId: Number(orderId)
+      orderId: Number(orderId),
+      merge: true
       // forceRemote: true,
     });
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "2.2.215",
+  "version": "2.2.217",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",