@pisell/pisellos 2.2.291 → 2.2.293

package/lib/server/index.js

@@ -27,6 +27,7 @@ var _filterBookings = require("./modules/order/utils/filterBookings");
 var _smallTicket = require("./utils/small-ticket");
 var _BaseSales = require("../solution/BaseSales");
 var _paymentUtils = require("../modules/Order/payment-utils");
+var _salesNotes = require("../modules/Order/salesNotes");
 var _modules = require("./modules");
 Object.keys(_modules).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -99,6 +100,8 @@ class Server {
   productQueryScheduleTimers = new Map();
   /** 餐牌筛选为空时才触发的菜单/日程缓存自愈，避免每次商品查询都请求远端。 */
   menuScheduleRefreshInFlight = null;
+  /** 启动阶段模块预加载任务；预渲染商品查询复用该任务，避免缓存尚未 ready 时误触发远端自愈。 */
+  startupModulePreloadInFlight = null;
   lastMenuScheduleRefreshAt = 0;
   MENU_SCHEDULE_REFRESH_COOLDOWN_MS = 30 * 1000;
 
@@ -501,7 +504,15 @@ class Server {
 
     // 自动预加载数据
     if (autoPreload) {
-      await this.preloadModulesData(registeredModules, options);
+      const preloadTask = this.preloadModulesData(registeredModules, options);
+      this.startupModulePreloadInFlight = preloadTask;
+      try {
+        await preloadTask;
+      } finally {
+        if (this.startupModulePreloadInFlight === preloadTask) {
+          this.startupModulePreloadInFlight = null;
+        }
+      }
     } else {
       this.logInfo('跳过自动预加载', {
         autoPreload
@@ -619,12 +630,16 @@ class Server {
     const numberedData = await this.ensureCheckoutOrderNumbers(normalizedData, title);
     const checkoutData = this.applyCheckoutFulfillmentBuzzer(numberedData, title);
     const remoteCheckoutData = this.buildRemoteCheckoutData(checkoutData, title);
+    const deviceHeaders = await this.buildCheckoutDeviceHeaders(title);
     if (!this.app?.request?.post) {
       throw new Error('app.request 不可用');
     }
     const response = await this.app.request.post(backendPath, remoteCheckoutData, {
       isShopApi: true,
-      customToast: () => {}
+      customToast: () => {},
+      ...(Object.keys(deviceHeaders).length > 0 ? {
+        headers: deviceHeaders
+      } : {})
     });
     if (this.isCheckoutResponseRejected(response)) {
       return {
@@ -687,6 +702,7 @@ class Server {
     if (!next || typeof next !== 'object') return next;
     const record = next;
     delete record[OS_FULFILLMENT_REF_MODE_FIELD];
+    this.applyKioskCheckoutOperator(record);
     if (!Array.isArray(record.payments)) return next;
     const originalPayments = record.payments;
     const filteredPayments = originalPayments.filter(payment => !(0, _paymentUtils.isPendingOrderPayment)(payment));
@@ -701,6 +717,44 @@ class Server {
     });
     return next;
   }
+  async buildCheckoutDeviceHeaders(title) {
+    const getAsyncIotDeviceInfo = this.getAppData('async_iot_device_info');
+    if (!getAsyncIotDeviceInfo) return {};
+    let deviceInfo;
+    try {
+      deviceInfo = typeof getAsyncIotDeviceInfo === 'function' ? await getAsyncIotDeviceInfo() : getAsyncIotDeviceInfo;
+    } catch (error) {
+      this.logWarning(`${title}: 读取 async_iot_device_info 失败，跳过 checkout 设备请求头`, {
+        error: this.getUnknownErrorMessage(error)
+      });
+      return {};
+    }
+    if (!deviceInfo || typeof deviceInfo !== 'object') return {};
+    const headers = {};
+    const assignHeader = (key, value) => {
+      if (this.isBlankCheckoutValue(value)) return;
+      headers[key] = String(value);
+    };
+    assignHeader('Device-ID', deviceInfo.id);
+    assignHeader('Device-Type-Code', deviceInfo.type_code);
+    assignHeader('Device-Model-Code', deviceInfo.model_code);
+    return headers;
+  }
+  applyKioskCheckoutOperator(record) {
+    if (record.platform !== 'kiosk') return;
+    record.operator_type = 'customer';
+    record.operator_id = this.resolveKioskCheckoutOperatorId(record.customer_id);
+  }
+  resolveKioskCheckoutOperatorId(customerId) {
+    if (customerId === undefined || customerId === null) return 1;
+    if (typeof customerId === 'string') {
+      const trimmed = customerId.trim();
+      if (trimmed === '' || trimmed === '0' || trimmed === '1') return 1;
+      return customerId;
+    }
+    if (customerId === 0 || customerId === 1) return 1;
+    return customerId;
+  }
   mergeCheckoutSyncPayments(checkoutData, fresh, title) {
     const localPayments = Array.isArray(checkoutData?.payments) ? checkoutData.payments : [];
     const freshRecord = fresh;
@@ -802,11 +856,24 @@ class Server {
       return;
     }
     try {
-      await this.schedule.loadAllSchedule();
       this.products.clearPriceCache();
       await this.products.setupQuotationPriceBridge({
         scheduleModule: this.schedule,
-        channel: this.core.context?.channel
+        channel: this.core.context?.channel,
+        onQuotationUpdated: () => {
+          void this.recomputeAndNotifyProductQuery();
+        }
+      });
+
+      // Schedule 已在模块 preload 阶段加载完成。价格桥接先使用本地数据，
+      // 远端刷新转为后台校准，避免二次启动重复阻塞请求。
+      void this.schedule.loadAllSchedule().then(() => {
+        this.products?.clearPriceCache();
+        void this.recomputeAndNotifyProductQuery();
+      }).catch(error => {
+        this.logWarning('Products 报价单价格桥接后台刷新 Schedule 失败，继续使用本地数据', {
+          error: error instanceof Error ? error.message : String(error)
+        });
       });
       this.logInfo('Products 报价单价格桥接初始化完成');
     } catch (error) {
@@ -865,17 +932,23 @@ class Server {
    * 重新拉取全量 SSE 接口，更新本地数据后触发 onProductsSyncCompleted
    * 不影响当前界面展示，适用于切回前台、定时刷新等场景
    */
-  async refreshProductsInBackground() {
+  async refreshProductsInBackground(options = {}) {
     if (!this.products) {
       this.logWarning('refreshProductsInBackground: Products 模块未注册');
       return;
     }
-    this.logInfo('refreshProductsInBackground 开始');
+    const trigger = options.trigger || 'background';
+    this.logInfo('refreshProductsInBackground 开始', {
+      trigger
+    });
     const startTime = Date.now();
     try {
-      await this.products.silentRefresh();
+      await this.products.silentRefresh({
+        trigger
+      });
       const duration = Date.now() - startTime;
       this.logInfo('refreshProductsInBackground 完成', {
+        trigger,
         duration: `${duration}ms`
       });
     } catch (error) {
@@ -883,6 +956,7 @@ class Server {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Server] refreshProductsInBackground 失败:', error);
       this.logError('refreshProductsInBackground 失败', {
+        trigger,
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -894,17 +968,23 @@ class Server {
    * 重新拉取全量 SSE 接口，更新本地数据后触发 onOrdersSyncCompleted
    * 不影响当前界面展示，适用于切回前台、定时刷新等场景
    */
-  async refreshOrdersInBackground() {
+  async refreshOrdersInBackground(options = {}) {
     if (!this.order) {
       this.logWarning('refreshOrdersInBackground: Order 模块未注册');
       return;
     }
-    this.logInfo('refreshOrdersInBackground 开始');
+    const trigger = options.trigger || 'background';
+    this.logInfo('refreshOrdersInBackground 开始', {
+      trigger
+    });
     const startTime = Date.now();
     try {
-      await this.order.silentRefresh();
+      await this.order.silentRefresh({
+        trigger
+      });
       const duration = Date.now() - startTime;
       this.logInfo('refreshOrdersInBackground 完成', {
+        trigger,
         duration: `${duration}ms`
       });
     } catch (error) {
@@ -912,6 +992,7 @@ class Server {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Server] refreshOrdersInBackground 失败:', error);
       this.logError('refreshOrdersInBackground 失败', {
+        trigger,
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -1448,7 +1529,7 @@ class Server {
     //   timerIds.push(timerId);
     // }
     setInterval(() => {
-      const currentTime = (0, _dayjs.default)().format('hh:mm');
+      const currentTime = (0, _dayjs.default)().format('HH:mm');
       if (timePoints.includes(currentTime)) {
         this.onScheduleTimePointTimerFire(subscriberId);
       }
@@ -3507,14 +3588,16 @@ class Server {
     };
     const needsShopOrderNumber = next.shop_order_number === undefined || next.shop_order_number === null || next.shop_order_number === '';
     const needsShopFullOrderNumber = next.shop_full_order_number === undefined || next.shop_full_order_number === null || next.shop_full_order_number === '';
-    if (!needsShopOrderNumber && !needsShopFullOrderNumber) return next;
+    if (!needsShopOrderNumber && !needsShopFullOrderNumber) {
+      return this.finalizeCheckoutSalesNotes(next, title);
+    }
     const idGenerator = this.getIdGeneratorPlugin();
     if (!idGenerator) {
       this.logWarning(`${title}: idGenerator 插件不可用，无法生成订单号`, {
         needsShopOrderNumber,
         needsShopFullOrderNumber
       });
-      return next;
+      return this.finalizeCheckoutSalesNotes(next, title);
     }
     try {
       if (needsShopOrderNumber && idGenerator.generateShopOrderNumber) {
@@ -3536,7 +3619,38 @@ class Server {
         error: error instanceof Error ? error.message : String(error)
       });
     }
-    return next;
+    return this.finalizeCheckoutSalesNotes(next, title);
+  }
+
+  /**
+   * Notes 允许在本地草稿阶段暂存空订单目标；checkout 的统一出口负责用最终
+   * shop_order_number 完成绑定并校验，保证后端请求、pending、设备任务和打印
+   * 都使用同一份完整快照。
+   */
+  finalizeCheckoutSalesNotes(data, title) {
+    if (!data || typeof data !== 'object') return data;
+    if (!Object.prototype.hasOwnProperty.call(data, 'notes')) return data;
+    if (data.notes === undefined || data.notes === null) return data;
+    if (!Array.isArray(data.notes)) {
+      throw new Error('[Order Notes] checkout notes 必须为数组');
+    }
+    if (data.notes.length === 0) return data;
+    const productTargetUuids = (Array.isArray(data.products) ? data.products : []).map(product => product?.metadata?.unique_identification_number ?? product?.unique_identification_number).filter(targetUuid => targetUuid !== undefined && targetUuid !== null && String(targetUuid).trim().length > 0).map(targetUuid => String(targetUuid));
+    const shopOrderNumber = String(data.shop_order_number ?? '').trim();
+    const notes = (0, _salesNotes.finalizeSalesNotesForCheckout)({
+      notes: data.notes,
+      shopOrderNumber,
+      productTargetUuids
+    });
+    this.logInfo(`${title}: checkout Notes 已绑定订单号`, {
+      shop_order_number: shopOrderNumber,
+      note_count: notes.length
+    });
+    return {
+      ...data,
+      shop_order_number: shopOrderNumber,
+      notes
+    };
   }
   async dispatchCheckoutSyncTask(params) {
     this.registerDeviceTaskActions();
@@ -3593,7 +3707,8 @@ class Server {
             order_id: printIdentity,
             small_ticket_data: params.syncedOrder?.payment_info?.small_ticket_data,
             skip_wristband: true,
-            skip_voucher: true
+            skip_voucher: true,
+            skip_discount: true
           } : {
             order_id: printIdentity,
             machine_code_print_info: params.syncedOrder?.payment_info?.machine_code_print_info,
@@ -5387,12 +5502,6 @@ class Server {
       strategy_context
     } = context;
     const queryIds = Array.isArray(ids) ? ids.map(id => Number(id)).filter(id => Number.isFinite(id)) : [];
-    const formatterContext = this.buildProductFormatterContext({
-      schedule_date,
-      schedule_datetime,
-      customer_id,
-      strategy_context
-    });
     this.logInfo('computeProductQueryResult 开始', {
       menuListIdsCount: menu_list_ids?.length ?? 0,
       ids: queryIds,
@@ -5404,6 +5513,23 @@ class Server {
       strategyContextKeys: strategy_context ? Object.keys(strategy_context) : [],
       changedIds: options?.changedIds
     });
+
+    // 预渲染可能在 PisellOS 顺序 preload 尚未完成时发起商品查询。此时 Menu/Schedule
+    // 暂时为空不代表缓存失效；等待当前 preload 后再按原逻辑查询，避免并发远端刷新先 clear
+    // SQLite/IndexDB，造成 preload 读到空数据并重复请求。正常运行期该字段为 null，不增加等待。
+    const startupPreloadTask = this.startupModulePreloadInFlight;
+    if (startupPreloadTask) {
+      await startupPreloadTask;
+    }
+
+    // Menu/Schedule preload 会替换 store 中的数组；必须在等待完成后再读取，
+    // 避免 formatterContext 持有预加载前的空数组快照。
+    const formatterContext = this.buildProductFormatterContext({
+      schedule_date,
+      schedule_datetime,
+      customer_id,
+      strategy_context
+    });
     if (!this.products) {
       this.logError('computeProductQueryResult: Products 模块未注册');
       return {
@@ -5616,6 +5742,8 @@ class Server {
       schedule_datetime: context.schedule_datetime,
       customer_id: context.customer_id,
       strategy_context: context.strategy_context,
+      // 固定本次商品查询使用的语言，确保格式化与缓存使用同一份 locale 快照。
+      locale: this.core.context?.locale,
       menuList: this.menu?.getMenuList?.() || [],
       scheduleList: scheduleModule?.getScheduleList?.() || [],
       dataVariantEvaluator: this.core.context?.dataVariantEvaluator

package/lib/server/modules/floor-plan/index.d.ts

@@ -10,6 +10,7 @@ export declare class FloorPlanModule extends BaseModule implements Module {
     private store;
     private request;
     private logger;
+    private dbManager;
     private floorPlanDataSource;
     private pendingSyncMessages;
     private syncTimer?;
@@ -28,6 +29,9 @@ export declare class FloorPlanModule extends BaseModule implements Module {
     private mergeItems;
     private removeByIds;
     private loadListFromServer;
+    private loadListFromSQLite;
+    private saveListToSQLite;
+    private refreshListFromServer;
     fetchByIdFromServer(id: number | string): Promise<FloorPlanItem | null>;
     fetchByCodeFromServer(code: string): Promise<FloorPlanItem | null>;
     preload(): Promise<void>;

package/lib/server/modules/floor-plan/index.js

@@ -7,6 +7,7 @@ exports.FloorPlanModule = void 0;
 var _BaseModule = require("../../../modules/BaseModule");
 var _types = require("./types");
 const FLOOR_PLAN_SYNC_DEBOUNCE_MS = 3000;
+const FLOOR_PLAN_STORE_NAME = 'floor_plans';
 
 /**
  * 平面图模块：预加载列表、pubsub 同步、供 OS Server 路由读本地 store
@@ -17,6 +18,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
   store;
   request;
   logger;
+  dbManager;
   floorPlanDataSource;
   pendingSyncMessages = [];
   syncTimer;
@@ -40,6 +42,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
     if (appPlugin) {
       const app = appPlugin.getApp();
       this.logger = app.logger;
+      this.dbManager = app.sqlite || app.dbManager;
     }
     this.initFloorPlanDataSource();
     this.setupFloorPlanSync();
@@ -147,6 +150,45 @@ class FloorPlanModule extends _BaseModule.BaseModule {
       return [];
     }
   }
+  async loadListFromSQLite() {
+    if (!this.dbManager) return [];
+    try {
+      const list = await this.dbManager.getAll(FLOOR_PLAN_STORE_NAME);
+      return Array.isArray(list) ? list : [];
+    } catch (error) {
+      this.logWarning('从 SQLite 读取平面图失败', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async saveListToSQLite(list) {
+    if (!this.dbManager) return;
+    try {
+      await this.dbManager.clear(FLOOR_PLAN_STORE_NAME);
+      if (list.length > 0) {
+        await this.dbManager.bulkAdd(FLOOR_PLAN_STORE_NAME, list);
+      }
+    } catch (error) {
+      this.logWarning('保存平面图到 SQLite 失败', {
+        count: list.length,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async refreshListFromServer() {
+    const list = await this.loadListFromServer();
+    if (list.length === 0) {
+      this.logWarning('远端平面图刷新完成但列表为空');
+      return;
+    }
+    this.replaceStore(list);
+    await this.saveListToSQLite(list);
+    this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
+    this.logInfo('远端平面图刷新完成', {
+      count: list.length
+    });
+  }
   async fetchByIdFromServer(id) {
     try {
       const res = await this.request.get(`/schedule/floor-plan/${id}`, {}, {
@@ -174,16 +216,25 @@ class FloorPlanModule extends _BaseModule.BaseModule {
   }
   async preload() {
     this.logInfo('开始预加载平面图列表');
-    const list = await this.loadListFromServer();
-    if (list.length > 0) {
-      this.replaceStore(list);
+    const cachedList = await this.loadListFromSQLite();
+    if (cachedList.length > 0) {
+      this.replaceStore(cachedList);
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
-      this.logInfo('预加载完成', {
-        count: list.length
+      this.logInfo('预加载完成（SQLite）', {
+        count: cachedList.length
       });
-    } else {
-      this.logWarning('预加载完成但列表为空');
+
+      // 二次启动立即使用本地平面图，远端刷新完成后自动更新 store 与订阅者。
+      void this.refreshListFromServer().catch(error => {
+        this.logWarning('后台刷新平面图失败，继续使用本地数据', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+      return;
     }
+
+    // 首次启动没有缓存时仍等待一次远端请求，并为后续启动建立缓存。
+    await this.refreshListFromServer();
   }
   initFloorPlanDataSource() {
     const Ctor = this.core.serverOptions?.All_DATA_SOURCES?.FloorPlanDataSource;
@@ -282,6 +333,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
       }
     }
     if (changed) {
+      await this.saveListToSQLite(this.store.list);
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlansChanged, this.getSortedList());
       this.core.effects.emit(_types.FloorPlanHooks.onFloorPlanSyncCompleted, null);
     }
@@ -290,6 +342,7 @@ class FloorPlanModule extends _BaseModule.BaseModule {
     this.store.list = [];
     this.store.map.clear();
     this.store.codeMap.clear();
+    await this.saveListToSQLite([]);
   }
   destroy() {
     if (this.syncTimer) {

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

@@ -190,17 +190,20 @@ class MenuModule extends _BaseModule.BaseModule {
       this.logWarning('loadMenuFromIndexDB: dbManager 不可用');
       return [];
     }
+    const startedAt = performance.now();
     try {
       // 直接获取所有餐牌记录
       const menuList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
       this.logInfo('从 IndexDB 加载餐牌数据', {
-        menuCount: menuList?.length ?? 0
+        menuCount: menuList?.length ?? 0,
+        durationMs: +(performance.now() - startedAt).toFixed(2)
       });
       return menuList || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Menu] 从 IndexDB 读取数据失败:', error);
       this.logError('从 IndexDB 读取数据失败', {
+        durationMs: +(performance.now() - startedAt).toFixed(2),
         error: errorMessage
       });
       return [];
@@ -216,24 +219,43 @@ class MenuModule extends _BaseModule.BaseModule {
       this.logWarning('saveMenuToIndexDB: dbManager 不可用');
       return;
     }
+    const startedAt = performance.now();
+    let clearDurationMs = 0;
+    let writeDurationMs = 0;
     this.logInfo('开始保存餐牌数据到 IndexDB', {
       menuCount: menuList.length
     });
     try {
       // 先清空现有的餐牌数据
-      await this.dbManager.clear(INDEXDB_STORE_NAME);
+      const clearStartedAt = performance.now();
+      try {
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+      } finally {
+        clearDurationMs = +(performance.now() - clearStartedAt).toFixed(2);
+      }
 
       // 逐个保存餐牌（每个餐牌是独立的记录）
+      const writeStartedAt = performance.now();
       const savePromises = menuList.map(menu => this.dbManager.add(INDEXDB_STORE_NAME, menu));
-      await Promise.all(savePromises);
+      try {
+        await Promise.all(savePromises);
+      } finally {
+        writeDurationMs = +(performance.now() - writeStartedAt).toFixed(2);
+      }
       this.logInfo('餐牌数据已保存到 IndexDB', {
-        menuCount: menuList.length
+        menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2)
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error('[Menu] 保存数据到 IndexDB 失败:', error);
       this.logError('保存数据到 IndexDB 失败', {
         menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2),
         error: errorMessage
       });
     }

package/lib/server/modules/order/index.d.ts

@@ -127,14 +127,23 @@ export declare class OrderModule extends BaseModule implements Module {
         payment: Record<string, any>;
         previousPayment: Record<string, any>;
     } | null>;
-    loadOrdersByServer(): Promise<OrderData[]>;
+    loadOrdersByServer(options?: {
+        trigger?: string;
+    }): Promise<OrderData[]>;
     /**
      * 静默全量刷新：后台重新拉取全量 SSE 订单数据并更新本地
      * 拿到完整数据后一次性替换 store，触发订单变更与同步完成事件
      * @returns 刷新后的订单列表
      */
-    silentRefresh(): Promise<OrderData[]>;
+    silentRefresh(options?: {
+        trigger?: string;
+    }): Promise<OrderData[]>;
     private normalizeOrderForMemoryList;
+    /**
+     * 将已经完成集合规范化的订单转换为内存身份，不重复扫描 products/bookings/payments。
+     */
+    private prepareNormalizedOrderForMemoryList;
+    private prepareNormalizedOrdersForMemoryList;
     private normalizeOrdersForMemoryList;
     private hasRealOrderId;
     private shouldKeepOrderInMemory;
@@ -299,13 +308,14 @@ export declare class OrderModule extends BaseModule implements Module {
     private logDuplicateOrders;
     private compactOrderListByIdentity;
     /**
-     * 当前订单拉取窗口：
-     * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
-     * - 无法解析时退化为自然日窗口
+     * 当前订单缓存可复用窗口。
+     * start_time 模式使用精确的营业日起止时间；配置缺失或异常时退化为自然日。
      */
-    private getCurrentPullWindow;
+    private getCurrentOrderCacheWindow;
     private hasPulledOrdersToday;
     private markOrderPulledAtNow;
+    private clearOrderSnapshotMarker;
+    private getCurrentShopId;
     private getStorageItem;
     private setStorageItem;
     private loadOrdersFromSQLite;
@@ -343,7 +353,7 @@ export declare class OrderModule extends BaseModule implements Module {
      * 用于 SSE 全量拉取与营业日窗口裁剪。
      *
      * @example
-     * await this.replaceOrdersSnapshotInSQLite(orderList)
+     * const { orders, persisted } = await this.replaceOrdersSnapshotInSQLite(orderList, 'refresh')
      */
     private replaceOrdersSnapshotInSQLite;
     /**