@pisell/pisellos 2.2.309 → 2.2.311

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

@@ -5,18 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PaymentServerModule = void 0;
 var _BaseModule = require("../../../modules/BaseModule");
+var _lodashEs = require("lodash-es");
 const WALLET_PASS_CODE = 'WALLET_PASS';
 const WALLET_DEPENDENT_CODES = new Set(['PRODUCTVOUCHER', 'GIFTCARD', 'POINTCARD']);
 const PAYMENT_METHODS_LOADED_EVENT = 'payment:onPaymentMethodsLoaded';
+const PAYMENT_METHODS_CHANGED_EVENT = 'payment:onPaymentMethodsChanged';
+const PAYMENT_METHOD_STORE_NAME = 'pay_method';
+const CUSTOM_PAYMENT_MODULE = 'custom_payment';
+const PAYMENT_METHOD_SYNC_DEBOUNCE_MS = 500;
+const SNAPSHOT_ORDER_FIELD = '__payment_snapshot_order';
+const SNAPSHOT_SHOP_ID_FIELD = '__payment_snapshot_shop_id';
 class PaymentServerModule extends _BaseModule.BaseModule {
   defaultName = 'payment';
   defaultVersion = '1.0.0';
   request;
   app;
   logger;
+  dbManager;
   store;
-  payMethodMemoryCache = null;
-  payMethodListInFlight = null;
+  paymentDataSource;
+  initialLoadInFlight = null;
+  refreshInFlight = null;
+  hasLoadedPayMethods = false;
+  hasEmittedLoaded = false;
+  syncTimer;
+  pendingMessageUuids = new Set();
+  queuedTrailingRefresh = false;
+  trailingMessageUuids = new Set();
   constructor(name, version) {
     super(name || 'payment', version);
   }
@@ -31,78 +46,327 @@ class PaymentServerModule extends _BaseModule.BaseModule {
     const appPlugin = core.getPlugin('app');
     this.app = appPlugin?.getApp();
     this.logger = this.app?.logger;
+    this.dbManager = this.app?.sqlite;
     if (!this.request && !this.app?.request) {
       throw new Error('PaymentServerModule 需要 request 插件或 app.request 支持');
     }
+    this.initPaymentDataSource();
+    this.setupPaymentMethodSync();
     this.logInfo('PaymentServerModule initialized successfully', {
-      hasAppRequest: !!this.app?.request
+      hasAppRequest: !!this.app?.request,
+      hasSQLite: !!this.dbManager,
+      hasPaymentDataSource: !!this.paymentDataSource
     });
   }
-
-  // getRoutes(): RouteDefinition[] {
-  //   return [
-  //     {
-  //       method: 'get',
-  //       path: '/pay/custom-payment/all',
-  //       handler: async ({ data, config }) => {
-  //         const payMethods = await this.getPayMethodListAsync({
-  //           shouldFilter: this.shouldFilterPayMethods(data, config),
-  //         });
-  //         return {
-  //           code: 200,
-  //           status: true,
-  //           data: payMethods,
-  //         };
-  //       },
-  //     },
-  //   ];
-  // }
-
+  async preload() {
+    try {
+      await this.ensureInitialPayMethods('preload');
+    } catch (error) {
+      this.logError('preload 支付方式失败，保持空列表并允许后续读取重试', {
+        error: this.getErrorMessage(error)
+      });
+    }
+  }
   async getPayMethodListAsync(options = {}) {
-    this.logInfo('Starting getPayMethodListAsync');
-    if (this.payMethodMemoryCache?.length) {
-      return this.resolvePayMethods(this.payMethodMemoryCache, options);
+    this.logInfo('Starting getPayMethodListAsync', {
+      hasLoadedPayMethods: this.hasLoadedPayMethods,
+      cachedCount: this.store.payMethods.length
+    });
+    if (!this.hasLoadedPayMethods) {
+      try {
+        await this.ensureInitialPayMethods('route');
+      } catch (error) {
+        this.logError('getPayMethodListAsync 初始化失败', {
+          error: this.getErrorMessage(error)
+        });
+      }
+    } else if (!this.paymentDataSource) {
+      try {
+        await this.refreshPayMethodsSingleFlight({
+          trigger: 'compat.route',
+          emitChanged: false
+        });
+      } catch (error) {
+        this.logWarning('兼容模式远端刷新失败，保留当前运行态快照', {
+          error: this.getErrorMessage(error)
+        });
+      }
     }
-    if (this.payMethodListInFlight) {
-      const payMethods = await this.payMethodListInFlight;
-      return this.resolvePayMethods(payMethods, options);
+    return this.resolvePayMethods(this.store.payMethods, options);
+  }
+  async ensureInitialPayMethods(trigger) {
+    if (this.hasLoadedPayMethods) return this.store.payMethods;
+    if (this.initialLoadInFlight) return this.initialLoadInFlight;
+    this.initialLoadInFlight = (async () => {
+      const localSnapshot = await this.loadPayMethodsFromSQLite();
+      if (localSnapshot.available) {
+        this.setPayMethodMirror(localSnapshot.methods);
+        this.logInfo('从 SQLite 加载支付方式兜底快照', {
+          trigger,
+          count: localSnapshot.methods.length,
+          shopScope: this.resolveCurrentShopScope(localSnapshot.methods)
+        });
+      }
+      try {
+        await this.refreshPayMethodsSingleFlight({
+          trigger,
+          emitChanged: false
+        });
+        this.hasLoadedPayMethods = true;
+      } catch (error) {
+        if (!localSnapshot.available) throw error;
+        this.hasLoadedPayMethods = true;
+        this.logWarning('远端刷新失败，继续使用 SQLite 支付方式快照', {
+          trigger,
+          count: localSnapshot.methods.length,
+          error: this.getErrorMessage(error)
+        });
+      }
+      if (!this.hasEmittedLoaded) {
+        this.hasEmittedLoaded = true;
+        await this.core.effects.emit(PAYMENT_METHODS_LOADED_EVENT, this.store.payMethods);
+      }
+      return this.store.payMethods;
+    })().finally(() => {
+      this.initialLoadInFlight = null;
+    });
+    return this.initialLoadInFlight;
+  }
+  initPaymentDataSource() {
+    const PaymentDataSourceClass = this.core.serverOptions?.All_DATA_SOURCES?.PaymentDataSource;
+    if (!PaymentDataSourceClass) {
+      this.logWarning('PaymentDataSource 不可用，使用无本地持久化的兼容模式');
+      return;
     }
-    this.payMethodListInFlight = this.loadPayMethodListAsync().finally(() => {
-      this.payMethodListInFlight = null;
+    this.paymentDataSource = new PaymentDataSourceClass();
+  }
+  setupPaymentMethodSync() {
+    if (!this.paymentDataSource) return;
+    this.paymentDataSource.run({
+      pubsub: {
+        callback: res => {
+          const message = res?.data || res;
+          if (!message || message.module !== CUSTOM_PAYMENT_MODULE) return;
+          const messageUuid = String(message.message_uuid || '').trim();
+          if (messageUuid) this.pendingMessageUuids.add(messageUuid);
+          this.logInfo('收到 custom_payment Ably 消息，等待全量刷新', {
+            message_uuid: messageUuid || undefined,
+            action: message.action,
+            operation: message.operation
+          });
+          this.schedulePaymentMethodRefresh();
+        }
+      }
+    }).catch(error => {
+      this.logError('建立 custom_payment pubsub 订阅失败', {
+        error: this.getErrorMessage(error)
+      });
     });
-    const payMethods = await this.payMethodListInFlight;
-    return this.resolvePayMethods(payMethods, options);
   }
-  clearPayMethodCache() {
-    this.payMethodMemoryCache = null;
-    this.store.payMethods = [];
+  schedulePaymentMethodRefresh() {
+    if (this.syncTimer) clearTimeout(this.syncTimer);
+    this.syncTimer = setTimeout(() => {
+      this.syncTimer = undefined;
+      const messageUuids = [...this.pendingMessageUuids];
+      this.pendingMessageUuids.clear();
+      void this.refreshPayMethodsSingleFlight({
+        trigger: 'ably',
+        emitChanged: true,
+        messageUuids
+      }).catch(error => {
+        this.logError('custom_payment Ably 全量刷新失败，保留旧快照', {
+          message_uuids: messageUuids,
+          error: this.getErrorMessage(error)
+        });
+      });
+    }, PAYMENT_METHOD_SYNC_DEBOUNCE_MS);
   }
-  async loadPayMethodListAsync() {
+  async refreshPayMethodsSingleFlight(context) {
+    if (this.refreshInFlight) {
+      if (context.trigger.startsWith('ably')) {
+        this.queuedTrailingRefresh = true;
+        context.messageUuids?.forEach(uuid => this.trailingMessageUuids.add(uuid));
+        this.logInfo('支付方式刷新进行中，已排队一次尾随刷新', {
+          trigger: context.trigger,
+          message_uuids: context.messageUuids || []
+        });
+      }
+      return this.refreshInFlight;
+    }
+    const refreshTask = this.performRemoteRefresh(context);
+    this.refreshInFlight = refreshTask;
     try {
-      const payMethods = await this.fetchRemotePayMethods();
-      this.setPayMethodCache(payMethods);
-      await this.core.effects.emit(PAYMENT_METHODS_LOADED_EVENT, payMethods);
-      this.logInfo('getPayMethodListAsync completed successfully', {
-        payMethods
+      return await refreshTask;
+    } finally {
+      if (this.refreshInFlight === refreshTask) this.refreshInFlight = null;
+      if (this.queuedTrailingRefresh) {
+        this.queuedTrailingRefresh = false;
+        const messageUuids = [...this.trailingMessageUuids];
+        this.trailingMessageUuids.clear();
+        void this.refreshPayMethodsSingleFlight({
+          trigger: 'ably.trailing',
+          emitChanged: true,
+          messageUuids
+        }).catch(error => {
+          this.logError('custom_payment 尾随刷新失败，保留当前快照', {
+            message_uuids: messageUuids,
+            error: this.getErrorMessage(error)
+          });
+        });
+      }
+    }
+  }
+  async performRemoteRefresh(context) {
+    const oldMethods = this.store.payMethods;
+    const payMethods = await this.fetchRemotePayMethods();
+    const persisted = await this.replacePayMethodsInSQLite(payMethods);
+    if (!persisted) {
+      this.logWarning('SQLite 不可用，支付方式仅用于当前运行时', {
+        trigger: context.trigger,
+        count: payMethods.length
       });
-      return payMethods;
-    } catch (error) {
-      console.error('[PaymentServerModule] 获取支付方式列表失败', error);
-      this.logError('getPayMethodListAsync failed', error);
-      return [];
     }
+    this.setPayMethodMirror(payMethods);
+    this.hasLoadedPayMethods = true;
+    const changed = !this.arePayMethodsEqual(oldMethods, payMethods);
+    if (context.emitChanged && changed) {
+      await this.core.effects.emit(PAYMENT_METHODS_CHANGED_EVENT, {
+        oldMethods,
+        newMethods: this.store.payMethods
+      });
+    }
+    this.logInfo('远端支付方式全量刷新成功', {
+      trigger: context.trigger,
+      message_uuids: context.messageUuids || [],
+      count: payMethods.length,
+      persisted,
+      changed
+    });
+    return this.store.payMethods;
   }
   async fetchRemotePayMethods() {
-    const requester = this.app?.request || this.request;
-    const response = await requester.get('/shop/pay/custom-payment/all', undefined);
-    const payMethods = response?.data || response || [];
-    return Array.isArray(payMethods) ? payMethods : [];
+    const response = this.paymentDataSource ? await this.paymentDataSource.run({
+      http: {
+        url: '/shop/pay/custom-payment/all'
+      }
+    }) : await (this.app?.request || this.request).get('/shop/pay/custom-payment/all', undefined);
+    const payMethods = response?.data !== undefined ? response.data : response;
+    if (!Array.isArray(payMethods)) {
+      throw new Error('支付方式全量接口返回值不是数组');
+    }
+    if (payMethods.some(method => !method || method.id === undefined || method.id === null)) {
+      throw new Error('支付方式全量接口存在缺少 id 的记录');
+    }
+    return payMethods;
+  }
+  async loadPayMethodsFromSQLite() {
+    if (!this.dbManager) return {
+      available: false,
+      methods: []
+    };
+    try {
+      const rows = await this.dbManager.getAll(PAYMENT_METHOD_STORE_NAME);
+      if (!Array.isArray(rows) || rows.length === 0) {
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const currentShopScope = this.resolveCurrentShopScope();
+      if (!currentShopScope) {
+        this.logWarning('无法确认当前店铺，忽略 SQLite 支付方式快照');
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const scopedRows = rows.filter(row => String(row?.[SNAPSHOT_SHOP_ID_FIELD] || '') === currentShopScope);
+      if (scopedRows.length === 0) {
+        this.logWarning('忽略其他店铺的 SQLite 支付方式快照', {
+          currentShopScope,
+          storedShopScopes: [...new Set(rows.map(row => String(row?.[SNAPSHOT_SHOP_ID_FIELD] || '')).filter(Boolean))]
+        });
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const methods = scopedRows.slice().sort((left, right) => Number(left?.[SNAPSHOT_ORDER_FIELD] || 0) - Number(right?.[SNAPSHOT_ORDER_FIELD] || 0)).map(row => this.stripSnapshotFields(row));
+      return {
+        available: true,
+        methods
+      };
+    } catch (error) {
+      this.logWarning('从 SQLite 读取支付方式失败', {
+        error: this.getErrorMessage(error)
+      });
+      return {
+        available: false,
+        methods: []
+      };
+    }
+  }
+  async replacePayMethodsInSQLite(payMethods) {
+    if (!this.dbManager) return false;
+    const previousRows = await this.dbManager.getAll(PAYMENT_METHOD_STORE_NAME);
+    const shopScope = this.resolveCurrentShopScope(payMethods);
+    const snapshotRows = payMethods.map((method, index) => ({
+      ...method,
+      [SNAPSHOT_ORDER_FIELD]: index,
+      [SNAPSHOT_SHOP_ID_FIELD]: shopScope
+    }));
+    try {
+      await this.dbManager.clear(PAYMENT_METHOD_STORE_NAME);
+      if (snapshotRows.length > 0) {
+        await this.dbManager.bulkAdd(PAYMENT_METHOD_STORE_NAME, snapshotRows);
+      }
+      return true;
+    } catch (error) {
+      const writeError = this.getErrorMessage(error);
+      try {
+        await this.dbManager.clear(PAYMENT_METHOD_STORE_NAME);
+        if (Array.isArray(previousRows) && previousRows.length > 0) {
+          await this.dbManager.bulkAdd(PAYMENT_METHOD_STORE_NAME, previousRows);
+        }
+      } catch (rollbackError) {
+        this.logError('支付方式 SQLite 快照回滚失败', {
+          writeError,
+          rollbackError: this.getErrorMessage(rollbackError)
+        });
+      }
+      throw new Error(`支付方式 SQLite 全量替换失败: ${writeError}`);
+    }
+  }
+  resolveCurrentShopScope(payMethods = []) {
+    const readStorageObject = key => {
+      try {
+        const raw = this.app?.storage?.getStorage?.(key);
+        if (!raw) return {};
+        if (typeof raw === 'object') return raw;
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+      } catch {
+        return {};
+      }
+    };
+    const selectedStore = readStorageObject('selectedStore');
+    const core = readStorageObject('core');
+    const scope = selectedStore.id ?? selectedStore.shop_id ?? core.id ?? core.shop_id ?? payMethods.find(method => method?.shop_id != null)?.shop_id;
+    return scope === undefined || scope === null ? '' : String(scope);
+  }
+  stripSnapshotFields(row) {
+    const {
+      [SNAPSHOT_ORDER_FIELD]: _snapshotOrder,
+      [SNAPSHOT_SHOP_ID_FIELD]: _snapshotShopId,
+      ...method
+    } = row;
+    return method;
   }
-  shouldFilterPayMethods(data, config) {
-    return data?.filterPaymentMethods === true || config?.filterPaymentMethods === true;
+  arePayMethodsEqual(left, right) {
+    return (0, _lodashEs.isEqual)(left, right);
   }
   resolvePayMethods(payMethods, options) {
-    if (!options.shouldFilter) return payMethods;
+    if (!options.shouldFilter) return [...payMethods];
     return this.filterPayMethods(payMethods);
   }
   filterPayMethods(payMethods) {
@@ -121,48 +385,56 @@ class PaymentServerModule extends _BaseModule.BaseModule {
     });
     return availableMethods;
   }
-  setPayMethodCache(payMethods) {
-    this.payMethodMemoryCache = payMethods;
-    this.store.payMethods = payMethods;
+  setPayMethodMirror(payMethods) {
+    this.store.payMethods = payMethods.map(method => ({
+      ...method
+    }));
+  }
+  getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
   }
   logInfo(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'info',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'info',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
   logWarning(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'warning',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'warning',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
   logError(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'error',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'error',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
+  destroy() {
+    if (this.syncTimer) clearTimeout(this.syncTimer);
+    this.syncTimer = undefined;
+    this.pendingMessageUuids.clear();
+    this.trailingMessageUuids.clear();
+    this.queuedTrailingRefresh = false;
+    this.paymentDataSource?.destroy?.();
+    this.paymentDataSource = undefined;
+    super.destroy();
+  }
 }
 exports.PaymentServerModule = PaymentServerModule;

package/lib/server/utils/small-ticket.d.ts

@@ -28,32 +28,35 @@ export interface SmallTicketItem {
     value: string;
     size?: number;
     align?: string;
+    product_uid?: string | number;
+    booking_uid?: string | number;
 }
 export interface SmallTicketProduct {
     product_title: string;
     product_quantity: number;
     selling_price: string;
+    total_selling_price: string;
     original_price: string;
     base_price?: string;
     total_original_price: string;
+    options_total_price?: string;
+    package_items_total_price?: string;
     extension_list: any[];
     product_uid?: string | number;
     booking_uid?: string | number;
     product_note?: string;
+    allergy?: string;
     options?: Array<{
         name: string;
         num?: number;
         price?: string;
+        total_price: string;
         value?: string;
     }>;
     variant?: string;
     combinations?: any[];
 }
-export interface SmallTicketBookingSnapshot extends Record<string, any> {
-    product_uid?: string | number;
-    booking_uid?: string | number;
-}
-export type SmallTicketAppointment = SmallTicketItem[] | SmallTicketBookingSnapshot[];
+export type SmallTicketAppointment = SmallTicketItem[];
 export interface SmallTicketLocaleData {
     base_data: Record<string, any>;
     products: SmallTicketProduct[];