@pisell/pisellos 2.3.74 → 2.3.76

package/lib/modules/Payment/index.js

@@ -1,92 +1,120 @@
-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;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  generateRequestUniqueId: true,
+  PaymentModule: true
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/modules/Payment/index.ts
-var Payment_exports = {};
-__export(Payment_exports, {
-  PaymentModule: () => PaymentModule,
-  generateRequestUniqueId: () => generateRequestUniqueId
+exports.PaymentModule = void 0;
+exports.generateRequestUniqueId = generateRequestUniqueId;
+var _BaseModule = require("../BaseModule");
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
 });
-module.exports = __toCommonJS(Payment_exports);
-var import_BaseModule = require("../BaseModule");
-var import_types = require("./types");
-var import_utils = require("../Cart/utils");
-var import_cash = require("./cash");
-var import_eftpos = require("./eftpos");
-var import_walletpass = require("./walletpass");
-var import_decimal = require("decimal.js");
-var import_payment_utils = require("../Order/payment-utils");
-var import_utils2 = require("../Order/utils");
-var import_payment_number = require("../../utils/payment-number");
-__reExport(Payment_exports, require("./types"), module.exports);
+var _utils = require("../Cart/utils");
+var _cash = require("./cash");
+var _eftpos = require("./eftpos");
+var _walletpass = require("./walletpass");
+var _decimal = require("decimal.js");
+var _paymentUtils = require("../Order/payment-utils");
+var _utils2 = require("../Order/utils");
+var _paymentNumber = require("../../utils/payment-number");
+/**
+ * 格式化金额为保留两位小数的字符串
+ */
 function formatAmount(amount) {
   try {
-    const decimal = new import_decimal.Decimal(amount);
+    const decimal = new _decimal.Decimal(amount);
     return decimal.toFixed(2);
   } catch (error) {
     console.warn(`[PaymentModule] 金额格式化失败: ${amount}，使用默认值 0.00`);
-    return "0.00";
+    return '0.00';
   }
 }
+
+/**
+ * 格式化日期时间为字符串
+ * 格式: YYYY-MM-DD HH:mm:ss
+ * 示例: 2025-12-10 16:14:50
+ */
 function formatDateTime(date) {
   const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
+
+/**
+ * 生成请求唯一ID
+ * 格式: 年月日时分秒毫秒+4位随机数
+ * 示例: 20241201143025123456
+ */
 function generateRequestUniqueId() {
-  const now = /* @__PURE__ */ new Date();
+  const now = new Date();
   const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  const hour = String(now.getHours()).padStart(2, "0");
-  const minute = String(now.getMinutes()).padStart(2, "0");
-  const second = String(now.getSeconds()).padStart(2, "0");
-  const millisecond = String(now.getMilliseconds()).padStart(3, "0");
-  const randomDigits = Math.floor(Math.random() * 9e3) + 1e3;
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hour = String(now.getHours()).padStart(2, '0');
+  const minute = String(now.getMinutes()).padStart(2, '0');
+  const second = String(now.getSeconds()).padStart(2, '0');
+  const millisecond = String(now.getMilliseconds()).padStart(3, '0');
+  const randomDigits = Math.floor(Math.random() * 9000) + 1000; // 1000-9999的4位随机数
+
   return `${year}${month}${day}${hour}${minute}${second}${millisecond}${randomDigits}`;
 }
 function normalizeCustomPaymentId(paymentItem) {
   const rawId = paymentItem.custom_payment_id ?? paymentItem.id ?? 0;
   const parsedId = Number(rawId);
-  if (!Number.isFinite(parsedId))
-    return 0;
+  if (!Number.isFinite(parsedId)) return 0;
   return parsedId;
 }
-var PaymentModule = class extends import_BaseModule.BaseModule {
+
+/**
+ * 支付模块实现
+ *
+ * 负责处理支付相关的数据管理和本地存储
+ */
+class PaymentModule extends _BaseModule.BaseModule {
+  defaultName = 'pay';
+  defaultVersion = '1.0.0';
+  request;
+  app; // App instance
+  appPlugin;
+  store;
+  window; // WindowPlugin 实例
+  dbManager; // IndexDBManager 实例
+  logger; // LoggerManager 实例
+  voucherUpdateLockByOrderUuid = new Map();
+  otherParams = {};
+
+  // 支付方式实例
+  cash;
+  eftpos;
+  wallet;
   constructor(name, version) {
     super(name || "payment", version);
-    this.defaultName = "pay";
-    this.defaultVersion = "1.0.0";
-    // LoggerManager 实例
-    this.voucherUpdateLockByOrderUuid = /* @__PURE__ */ new Map();
-    this.otherParams = {};
-    this.cash = new import_cash.CashPaymentImpl(this);
-    this.eftpos = new import_eftpos.EftposPaymentImpl(this);
-    this.wallet = new import_walletpass.WalletPassPaymentImpl(this);
+    // 初始化支付方式实例
+    this.cash = new _cash.CashPaymentImpl(this);
+    this.eftpos = new _eftpos.EftposPaymentImpl(this);
+    this.wallet = new _walletpass.WalletPassPaymentImpl(this);
   }
   runVoucherUpdateLocked(orderUuid, task) {
     const previous = this.voucherUpdateLockByOrderUuid.get(orderUuid) || Promise.resolve();
-    const next = previous.catch(() => void 0).then(task).finally(() => {
+    const next = previous.catch(() => undefined).then(task).finally(() => {
       if (this.voucherUpdateLockByOrderUuid.get(orderUuid) === next) {
         this.voucherUpdateLockByOrderUuid.delete(orderUuid);
       }
@@ -95,18 +123,21 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     return next;
   }
   normalizeVoucherPaymentItems(voucherPaymentItems) {
-    const normalized = /* @__PURE__ */ new Map();
+    const normalized = new Map();
     for (const item of voucherPaymentItems || []) {
-      if (!(item == null ? void 0 : item.voucher_id)) {
+      if (!item?.voucher_id) {
         throw new Error(`代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`);
       }
-      const orderPaymentType = item.order_payment_type || "normal";
+      const orderPaymentType = item.order_payment_type || 'normal';
       const key = `${item.voucher_id}|${orderPaymentType}`;
-      normalized.set(key, { ...item, order_payment_type: orderPaymentType });
+      normalized.set(key, {
+        ...item,
+        order_payment_type: orderPaymentType
+      });
     }
     return {
       items: Array.from(normalized.values()),
-      originalCount: (voucherPaymentItems == null ? void 0 : voucherPaymentItems.length) || 0,
+      originalCount: voucherPaymentItems?.length || 0,
       normalizedCount: normalized.size
     };
   }
@@ -114,22 +145,32 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     this.core = core;
     this.store = options.store;
     this.otherParams = options.otherParams || {};
-    this.request = core.getPlugin("request");
-    this.appPlugin = core.getPlugin("app");
-    this.window = core.getPlugin("window");
+
+    // 获取依赖的插件
+    this.request = core.getPlugin('request');
+    this.appPlugin = core.getPlugin('app');
+    this.window = core.getPlugin('window');
     if (!this.request) {
-      throw new Error("支付模块需要 request 插件支持");
+      throw new Error('支付模块需要 request 插件支持');
     }
     if (!this.appPlugin) {
-      throw new Error("支付模块需要 app 插件支持");
+      throw new Error('支付模块需要 app 插件支持');
     }
     this.app = this.appPlugin.getApp();
     this.dbManager = this.app.dbManager;
     this.logger = this.app.logger;
+
+    // 确保支付模块所需的对象存储已创建
+    // await this.ensurePaymentTables();
+
     this.registerNetworkHandlers();
-    console.log("[PaymentModule] 初始化完成");
-    this.logInfo("PaymentModule initialized successfully");
+
+    // // 预连接数据库
+    // this.dbManager.connect()
+
+    this.logInfo('PaymentModule initialized successfully');
   }
+
   /**
    * 更新父级解决方案透传的运行态参数，主要用于日志父模块等上下文。
    *
@@ -139,28 +180,26 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
   updateOtherParams(params) {
     this.otherParams = params || {};
   }
+
   /**
    * 获取标准化后的宿主平台标识，供支付子能力做平台边界判断。
    */
   getPlatform() {
-    var _a;
-    return String(((_a = this.otherParams) == null ? void 0 : _a.platform) || "").trim().toLowerCase();
+    return String(this.otherParams?.platform || '').trim().toLowerCase();
   }
   getPaymentNumberAppData(key) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const getData = (_b = (_a = this.appPlugin) == null ? void 0 : _a.getData) == null ? void 0 : _b.call(_a);
-    if (typeof getData === "function")
-      return getData(key);
-    const coreData = (_g = (_e = (_d = (_c = this.app) == null ? void 0 : _c.models) == null ? void 0 : _d.getStore) == null ? void 0 : (_f = _e.call(_d)).getDataByModel) == null ? void 0 : _g.call(_f, "core", "core");
-    return coreData == null ? void 0 : coreData[key];
+    const getData = this.appPlugin?.getData?.();
+    if (typeof getData === 'function') return getData(key);
+    const coreData = this.app?.models?.getStore?.().getDataByModel?.('core', 'core');
+    return coreData?.[key];
   }
+
   /**
    * 记录信息日志
    */
   logInfo(title, metadata) {
-    var _a, _b;
-    if ((_a = this.otherParams) == null ? void 0 : _a.fatherModule) {
-      const fatherModule = this.core.getModule((_b = this.otherParams) == null ? void 0 : _b.fatherModule);
+    if (this.otherParams?.fatherModule) {
+      const fatherModule = this.core.getModule(this.otherParams?.fatherModule);
       if (fatherModule) {
         fatherModule.logInfo(`${title}`, metadata);
         return;
@@ -168,31 +207,33 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     }
     if (this.logger) {
       this.logger.addLog({
-        type: "info",
+        type: 'info',
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
+
   /**
    * 记录警告日志
    */
   logWarning(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "warning",
+        type: 'warning',
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
+
   /**
    * 记录错误日志
    */
   logError(title, error, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "error",
+        type: 'error',
         title: `[PaymentModule] ${title}`,
         metadata: {
           error: error ? {
@@ -200,128 +241,182 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
             stack: error.stack,
             code: error.code,
             ...error
-          } : void 0,
-          ...metadata || {}
+          } : undefined,
+          ...(metadata || {})
         }
       });
     }
   }
+
   /**
    * 记录调试日志
    */
   logDebug(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "debug",
+        type: 'debug',
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
+
   /**
    * 网络恢复以后，尝试执行队列
    *
    */
   registerNetworkHandlers() {
-    const network = this.app.plugins.get("network");
-    this.logInfo("Registering network status listener");
-    network == null ? void 0 : network.addListener("networkStatusChange", async (status) => {
-      console.log("网络状态:", status.connected);
-      this.logInfo("Network status changed", {
+    const network = this.app.plugins.get('network');
+    this.logInfo('Registering network status listener');
+    network?.addListener('networkStatusChange', async status => {
+      this.logInfo('Network status changed', {
         connected: status.connected,
         previousStatus: status.previousStatus
       });
       if (status.connected) {
-        this.logInfo("Network reconnected");
+        this.logInfo('Network reconnected');
+        // 网络恢复时的处理逻辑可以在这里添加
       }
     });
   }
+
   /**
    * 获取支付方式列表
    */
   async getPayMethodListAsync() {
-    this.logInfo("Starting getPayMethodListAsync");
+    this.logInfo('Starting getPayMethodListAsync');
     try {
-      const response = await this.request.get("/pay/custom-payment/all", {
+      const response = await this.request.get('/pay/custom-payment/all', {
         filterPaymentMethods: true
       }, {
         osServer: true
       });
-      const payMethods = (response == null ? void 0 : response.data) || response || [];
-      this.logInfo("getPayMethodListAsync completed successfully", {
+      const payMethods = response?.data || response || [];
+      this.logInfo('getPayMethodListAsync completed successfully', {
         payMethods
       });
       return payMethods;
     } catch (error) {
-      console.error("[PaymentModule] 获取支付方式列表失败", error);
-      this.logError("getPayMethodListAsync failed", error);
+      console.error('[PaymentModule] 获取支付方式列表失败', error);
+      this.logError('getPayMethodListAsync failed', error);
+      // 如果所有操作都失败，返回空数组
       return [];
     }
   }
+
   /**
    * 获取订单列表
    */
   /** @deprecated */
   async getOrderListAsync() {
     try {
-      return await this.dbManager.getAll("order");
+      return await this.dbManager.getAll('order');
     } catch (error) {
-      console.error("[PaymentModule] 获取订单列表失败", error);
+      console.error('[PaymentModule] 获取订单列表失败', error);
       return [];
     }
   }
+
   /**
    * 根据订单UUID获取支付订单（新方法）
    */
   async getPaymentOrderByUuidAsync(orderUuid) {
     try {
-      return await this.dbManager.get("order", orderUuid, true);
+      return await this.dbManager.get('order', orderUuid, true);
     } catch (error) {
-      console.error("[PaymentModule] 获取支付订单失败", error);
+      console.error('[PaymentModule] 获取支付订单失败', error);
       return null;
     }
   }
+
   /**
    * 创建支付订单（新方法，专注支付数据）
    */
   async createPaymentOrderAsync(params) {
-    this.logInfo("Starting createPaymentOrderAsync", {
+    this.logInfo('Starting createPaymentOrderAsync', {
       orderId: params.order_id,
       totalAmount: params.total_amount
     });
     try {
+      // 检测是否有重复的 order_id
+      // console.time('createLocalOrderAsync: getExistingOrder')
+      // const existingOrder = await this.dbManager.get('order', params.order_id);
+      // const existingOrders = await this.dbManager.getAll('order');
+      // const existingOrder = existingOrders.find(
+      //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
+      // );
+
+      // this.logInfo('createPaymentOrderAsync existingOrder', {
+      //   existingOrder
+      // });
+      // console.timeEnd('createLocalOrderAsync: getExistingOrder')
+      // const existingOrder = existingOrders.find(
+      //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
+      // );
+
+      // if (existingOrder) {
+      //   // 如果存在相同 order_id 的订单，更新该订单信息
+      //   this.logInfo(
+      //     `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`,
+      //   );
+
+      //   // const originalOrder = { ...existingOrder };
+      //   existingOrder.order_info = params.order_info;
+      //   existingOrder.total_amount = params.total_amount;
+      //   existingOrder.is_deposit = params.is_deposit || 0;
+      //   existingOrder.deposit_amount = params.deposit_amount || '0.00';
+
+      //   // 重新计算待付金额
+      //   this.recalculateOrderAmount(existingOrder);
+
+      //   // 更新到数据库
+      //   await this.dbManager.update('order', existingOrder);
+
+      //   // 触发更新事件
+      //   this.core.effects.emit(
+      //     `${this.name}:onOrderUpdated`,
+      //     existingOrder,
+      //   );
+
+      //   return existingOrder;
+      // } else {
+      // 创建新的支付订单
       const newOrder = {
-        uuid: (0, import_utils.getUniqueId)("pay_order_"),
+        uuid: (0, _utils.getUniqueId)('pay_order_'),
         id: params.order_id,
         order_id: params.order_id,
         order_info: params.order_info,
-        payment_status: import_types.PaymentStatus.Processing,
+        payment_status: _types.PaymentStatus.Processing,
         payment: [],
         adjust_offline_payments: [],
         total_amount: params.total_amount,
         expect_amount: params.total_amount,
-        tax_fee: "0.00",
+        tax_fee: '0.00',
         is_deposit: params.is_deposit || 0,
-        deposit_amount: params.deposit_amount || "0.00"
+        deposit_amount: params.deposit_amount || '0.00'
       };
+
+      // 🔧 新增: 处理云端已存在的支付项
       if (params.existPayment && params.existPayment.length > 0) {
-        const currentTime = formatDateTime(/* @__PURE__ */ new Date());
-        newOrder.payment = params.existPayment.map((payment) => ({
+        const currentTime = formatDateTime(new Date());
+        newOrder.payment = params.existPayment.map(payment => ({
           ...payment,
           isSynced: true,
           // 标记为已同步
-          status: payment.status || "active",
+          status: payment.status || 'active',
           // 如果云端支付项已有时间戳，则保留；否则使用当前时间
           created_at: payment.created_at || currentTime,
           updated_at: payment.updated_at || currentTime
         }));
+
+        // 重新计算待付金额
         this.recalculateOrderAmount(newOrder);
-        this.logInfo("创建订单时包含云端支付项", {
+        this.logInfo('创建订单时包含云端支付项', {
           orderId: params.order_id,
           existPaymentCount: params.existPayment.length,
           totalAmount: newOrder.total_amount,
           expectAmount: newOrder.expect_amount,
-          paymentDetails: params.existPayment.map((p) => ({
+          paymentDetails: params.existPayment.map(p => ({
             uuid: p.uuid,
             code: p.code,
             amount: p.amount,
@@ -331,67 +426,75 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
           }))
         });
       }
+
+      // 🚀 性能监控：记录数据库添加操作耗时
       const dbAddStartTime = Date.now();
-      await this.dbManager.add("order", newOrder, true);
+      await this.dbManager.add('order', newOrder, true);
       const dbAddDuration = Date.now() - dbAddStartTime;
-      this.logInfo("Database add operation completed", {
-        operation: "dbManager.add",
-        table: "order",
+      this.logInfo('Database add operation completed', {
+        operation: 'dbManager.add',
+        table: 'order',
         orderUuid: newOrder.uuid,
         orderId: newOrder.order_id,
         duration: `${dbAddDuration}ms`,
-        performance: dbAddDuration > 100 ? "slow" : dbAddDuration > 50 ? "medium" : "fast"
+        performance: dbAddDuration > 100 ? 'slow' : dbAddDuration > 50 ? 'medium' : 'fast'
       });
       setTimeout(() => {
         this.core.effects.emit(`${this.name}:onOrderAdded`, newOrder);
       }, 0);
       return newOrder;
+      // }
     } catch (error) {
-      console.error("[PaymentModule] 创建支付订单失败", error);
-      this.logError("createPaymentOrderAsync failed", error, {
+      console.error('[PaymentModule] 创建支付订单失败', error);
+      this.logError('createPaymentOrderAsync failed', error, {
         orderId: params.order_id
       });
       throw error;
     }
   }
+
   /**
    * 删除支付订单（新方法）
    */
   async deletePaymentOrderAsync(orderUuid) {
     try {
-      const order = await this.dbManager.get("order", orderUuid);
+      const order = await this.dbManager.get('order', orderUuid);
       if (order) {
-        await this.dbManager.delete("order", orderUuid);
+        await this.dbManager.delete('order', orderUuid);
         await this.core.effects.emit(`${this.name}:onOrderDeleted`, order);
-        console.log("[PaymentModule] 支付订单删除成功:", orderUuid);
       }
     } catch (error) {
-      console.error("[PaymentModule] 删除支付订单失败", error);
+      console.error('[PaymentModule] 删除支付订单失败', error);
       throw error;
     }
   }
+
   /**
    * 更新订单
    */
   async updateOrderAsync(orderUuid, params) {
     try {
-      const order = await this.dbManager.get("order", orderUuid);
+      const order = await this.dbManager.get('order', orderUuid);
       if (order) {
-        const updatedOrder = { ...order, ...params };
+        const updatedOrder = {
+          ...order,
+          ...params
+        };
         this.recalculateOrderAmount(updatedOrder);
-        await this.dbManager.update("order", updatedOrder);
+        await this.dbManager.update('order', updatedOrder);
         await this.core.effects.emit(`${this.name}:onOrderUpdated`, updatedOrder);
         await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-          action: "update",
+          action: 'update',
           order: updatedOrder,
           originalOrder: order
         });
       }
     } catch (error) {
-      console.error("[PaymentModule] 更新订单失败", error);
+      console.error('[PaymentModule] 更新订单失败', error);
       throw error;
     }
   }
+
   /**
    * 基于UUID替换订单ID
    * 
@@ -403,28 +506,35 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    * @returns 更新后的订单对象，如果订单不存在则返回null
    */
   async replaceOrderIdByUuidAsync(orderUuid, newOrderId) {
-    this.logInfo("Starting replaceOrderIdByUuidAsync", {
+    this.logInfo('Starting replaceOrderIdByUuidAsync', {
       orderUuid,
       newOrderId
     });
     try {
-      const existingOrder = await this.dbManager.get("order", orderUuid);
+      // 获取现有订单
+      const existingOrder = await this.dbManager.get('order', orderUuid);
       if (!existingOrder) {
-        this.logWarning("Order not found for UUID replacement", { orderUuid });
+        this.logWarning('Order not found for UUID replacement', {
+          orderUuid
+        });
         return null;
       }
-      const allOrders = await this.dbManager.getAll("order");
-      const duplicateOrder = allOrders.find(
-        (order) => String(order.order_id) === String(newOrderId) && order.uuid !== orderUuid
-      );
+
+      // 检查新的订单ID是否已经存在
+      const allOrders = await this.dbManager.getAll('order');
+      const duplicateOrder = allOrders.find(order => String(order.order_id) === String(newOrderId) && order.uuid !== orderUuid);
       if (duplicateOrder) {
-        this.logWarning("New order ID already exists", {
+        this.logWarning('New order ID already exists', {
           newOrderId,
           existingOrderUuid: duplicateOrder.uuid
         });
         throw new Error(`订单ID ${newOrderId} 已存在`);
       }
+
+      // 保存原始订单ID用于日志
       const originalOrderId = existingOrder.id;
+
+      // 更新订单ID
       const updatedOrder = {
         ...existingOrder,
         id: newOrderId,
@@ -435,13 +545,17 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
           order_id: newOrderId,
           // 保留原始本地订单ID作为参考
           original_local_order_id: originalOrderId,
-          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+          updated_at: new Date().toISOString()
         }
       };
-      await this.dbManager.update("order", updatedOrder);
+
+      // 更新到数据库
+      await this.dbManager.update('order', updatedOrder);
+
+      // 触发事件
       await this.core.effects.emit(`${this.name}:onOrderUpdated`, updatedOrder);
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: "order_id_replaced",
+        action: 'order_id_replaced',
         order: updatedOrder,
         originalOrder: existingOrder,
         metadata: {
@@ -449,22 +563,22 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
           newOrderId
         }
       });
-      this.logInfo("Order ID replacement completed successfully", {
+      this.logInfo('Order ID replacement completed successfully', {
         orderUuid,
         originalOrderId,
         newOrderId
       });
-      console.log(`[PaymentModule] 订单ID替换成功: ${originalOrderId} → ${newOrderId}`);
       return updatedOrder;
     } catch (error) {
-      console.error("[PaymentModule] 替换订单ID失败", error);
-      this.logError("replaceOrderIdByUuidAsync failed", error, {
+      console.error('[PaymentModule] 替换订单ID失败', error);
+      this.logError('replaceOrderIdByUuidAsync failed', error, {
         orderUuid,
         newOrderId
       });
       throw error;
     }
   }
+
   /**
    * 获取支付项（新方法）
    * 
@@ -474,15 +588,18 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    */
   async getPaymentItemsAsync(orderUuid, includeVoided = false) {
     if (!orderUuid) {
-      throw new Error("orderUuid is required");
+      throw new Error('orderUuid is required');
     }
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
-    const allPayments = (order == null ? void 0 : order.payment) || [];
+    const allPayments = order?.payment || [];
     if (includeVoided) {
       return allPayments;
     }
-    return allPayments.filter((payment) => payment.status !== "voided");
+
+    // 默认只返回活跃的支付项
+    return allPayments.filter(payment => payment.status !== 'voided');
   }
+
   /**
    * 获取所有支付项（包括已撤销的）
    * 
@@ -492,64 +609,62 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
   async getAllPaymentItemsAsync(orderUuid) {
     return this.getPaymentItemsAsync(orderUuid, true);
   }
+
   /**
    * 为某个订单添加支付项（新方法）
    */
   async addPaymentItemAsync(orderUuid, paymentItem) {
-    var _a, _b, _c, _d;
-    this.logInfo("Starting addPaymentItemAsync", {
+    this.logInfo('Starting addPaymentItemAsync', {
       orderUuid,
       paymentAmount: paymentItem.amount,
       paymentCode: paymentItem.code,
       orderPaymentType: paymentItem.order_payment_type
     });
     try {
-      this.logInfo("准备获取订单", {
+      this.logInfo('准备获取订单', {
         orderUuid
       });
       const order = await this.getPaymentOrderByUuidAsync(orderUuid);
-      this.logInfo("获取订单信息成功", {
+      this.logInfo('获取订单信息成功', {
         orderUuid,
         order
       });
       if (!order) {
         throw new Error(`Order not found: ${orderUuid}`);
       }
-      const expectAmount = new import_decimal.Decimal(order.expect_amount);
+
+      // 🔒 支付锁检查：如果订单待付金额已经为0，不允许继续添加支付项
+      const expectAmount = new _decimal.Decimal(order.expect_amount);
       const paidDepositAmount = order.payment.reduce((sum, payment) => {
-        if (payment.order_payment_type === "deposit" && payment.status !== "voided") {
-          return sum.plus(new import_decimal.Decimal(payment.amount));
+        if (payment.order_payment_type === 'deposit' && payment.status !== 'voided') {
+          return sum.plus(new _decimal.Decimal(payment.amount));
         }
         return sum;
-      }, new import_decimal.Decimal(0));
-      const expectedDepositAmount = new import_decimal.Decimal(order.deposit_amount || "0").sub(paidDepositAmount);
+      }, new _decimal.Decimal(0));
+      const expectedDepositAmount = new _decimal.Decimal(order.deposit_amount || '0').sub(paidDepositAmount);
+
+      // 有一种特殊情况,订单金额为 0，但是定金金额>0，且此时是定金状态的，允许添加支付项
       if (expectAmount.lte(0) && expectedDepositAmount.eq(0)) {
         const warningMessage = `订单 ${orderUuid} 待付金额已为0，不允许添加新的支付项`;
-        console.warn("[PaymentModule] Payment lock triggered:", {
+        console.warn('[PaymentModule] Payment lock triggered:', {
           orderUuid,
           expectAmount: order.expect_amount,
           attemptedPaymentAmount: paymentItem.amount,
           attemptedPaymentCode: paymentItem.code,
-          reason: "Order already fully paid"
+          reason: 'Order already fully paid'
         });
-        this.logError("addPaymentItemAsync blocked by payment lock", new Error(warningMessage), {
+        this.logError('addPaymentItemAsync blocked by payment lock', new Error(warningMessage), {
           orderUuid,
           expectAmount: order.expect_amount,
           paymentItem
         });
         throw new Error(warningMessage);
       }
-      const paymentUuid = paymentItem.uuid || ((_a = paymentItem.metadata) == null ? void 0 : _a.unique_payment_number) || (0, import_utils.getUniqueId)("payment_");
-      const currentTime = formatDateTime(/* @__PURE__ */ new Date());
-      const hasPaymentNumber = String(paymentItem.payment_number || "").trim() !== "";
-      const paymentNumberDevicePrefix = hasPaymentNumber ? "LOCAL" : await (0, import_payment_number.resolvePaymentNumberDevicePrefix)(
-        (key) => this.getPaymentNumberAppData(key)
-      );
-      const paymentNumber = (0, import_payment_utils.ensureOrderPaymentNumber)(
-        paymentItem,
-        paymentNumberDevicePrefix,
-        import_utils2.createUuidV4
-      ).payment_number;
+      const paymentUuid = paymentItem.uuid || paymentItem.metadata?.unique_payment_number || (0, _utils.getUniqueId)('payment_');
+      const currentTime = formatDateTime(new Date());
+      const hasPaymentNumber = String(paymentItem.payment_number || '').trim() !== '';
+      const paymentNumberDevicePrefix = hasPaymentNumber ? 'LOCAL' : await (0, _paymentNumber.resolvePaymentNumberDevicePrefix)(key => this.getPaymentNumberAppData(key));
+      const paymentNumber = (0, _paymentUtils.ensureOrderPaymentNumber)(paymentItem, paymentNumberDevicePrefix, _utils2.createUuidV4).payment_number;
       const newPaymentItem = {
         uuid: paymentUuid,
         payment_number: paymentNumber,
@@ -558,114 +673,119 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         code: paymentItem.code,
         type: paymentItem.type,
         amount: formatAmount(paymentItem.amount),
-        voucher_id: paymentItem.voucher_id || "",
+        voucher_id: paymentItem.voucher_id || '',
         wallet_pass_usage_unit: paymentItem.wallet_pass_usage_unit,
         wallet_pass_use_value: paymentItem.wallet_pass_use_value,
-        rounding_amount: paymentItem.rounding_amount || "0.00",
+        rounding_amount: paymentItem.rounding_amount || '0.00',
         service_charge: paymentItem.service_charge,
-        status: "active",
+        status: 'active',
         // 新支付项默认为活跃状态
-        order_payment_type: paymentItem.order_payment_type || "normal",
+        order_payment_type: paymentItem.order_payment_type || 'normal',
         // 默认为正常支付
         created_at: currentTime,
         // 创建时间
         updated_at: currentTime,
         // 更新时间
         metadata: {
-          ...paymentItem.metadata
-          // 保留传入的所有 metadata 字段
+          ...paymentItem.metadata // 保留传入的所有 metadata 字段
         }
       };
       order.payment.push(newPaymentItem);
       this.recalculateOrderAmount(order);
-      this.logInfo("开始更新订单支付项", {
+      this.logInfo('开始更新订单支付项', {
         orderUuid,
         order
       });
-      await this.dbManager.update("order", order, true);
-      this.logInfo("更新订单支付项完成", {
+      await this.dbManager.update('order', order, true);
+      this.logInfo('更新订单支付项完成', {
         orderUuid
       });
       this.core.effects.emit(`${this.name}:onPaymentAdded`, {
         orderUuid,
         payment: newPaymentItem
       });
-      this.logInfo("addPaymentItemAsync completed successfully", {
+      this.logInfo('addPaymentItemAsync completed successfully', {
         orderUuid,
         paymentUuid: newPaymentItem.uuid,
-        uniquePaymentNumber: (_b = newPaymentItem.metadata) == null ? void 0 : _b.unique_payment_number,
+        uniquePaymentNumber: newPaymentItem.metadata?.unique_payment_number,
         newExpectAmount: order.expect_amount,
         paymentAmount: newPaymentItem.amount,
         paymentCode: newPaymentItem.code,
         orderPaymentType: newPaymentItem.order_payment_type,
         metadataFields: Object.keys(newPaymentItem.metadata || {}),
         // 现金支付找零信息
-        actualPaidAmount: (_c = newPaymentItem.metadata) == null ? void 0 : _c.actual_paid_amount,
-        changeGivenAmount: (_d = newPaymentItem.metadata) == null ? void 0 : _d.change_given_amount
+        actualPaidAmount: newPaymentItem.metadata?.actual_paid_amount,
+        changeGivenAmount: newPaymentItem.metadata?.change_given_amount
       });
     } catch (error) {
-      console.error("[PaymentModule] 添加支付项失败", error);
-      this.logError("addPaymentItemAsync failed", error, {
+      console.error('[PaymentModule] 添加支付项失败', error);
+      this.logError('addPaymentItemAsync failed', error, {
         orderUuid,
         paymentItem
       });
       throw error;
     }
   }
+
   /**
    * 删除一个支付项 - 标记删除而非物理删除
    */
   async deletePaymentAsync(orderUuid, paymentUuid) {
-    this.logInfo("Starting deletePaymentAsync (mark as voided)", { orderUuid, paymentUuid });
+    this.logInfo('Starting deletePaymentAsync (mark as voided)', {
+      orderUuid,
+      paymentUuid
+    });
     try {
-      const order = await this.dbManager.get("order", orderUuid);
+      const order = await this.dbManager.get('order', orderUuid);
       if (!order) {
-        throw new Error("订单不存在");
+        throw new Error('订单不存在');
       }
-      const paymentItem = order.payment.find(
-        (payment) => payment.uuid === paymentUuid
-      );
+      const paymentItem = order.payment.find(payment => payment.uuid === paymentUuid);
       if (!paymentItem) {
         throw new Error(`支付项不存在: ${paymentUuid}`);
       }
-      if (paymentItem.status === "voided") {
+
+      // 检查是否已经被删除（撤销）
+      if (paymentItem.status === 'voided') {
         console.warn(`[PaymentModule] 支付项 ${paymentUuid} 已经被删除，跳过操作`);
         return;
       }
-      paymentItem.status = "voided";
-      paymentItem.origin_amount = paymentItem.amount;
-      paymentItem.amount = "0.00";
-      console.log(`[PaymentModule] 支付项标记为删除:`, {
-        uuid: paymentItem.uuid,
-        originalAmount: paymentItem.origin_amount,
-        status: paymentItem.status
-      });
+
+      // 标记删除而不是物理删除
+      paymentItem.status = 'voided';
+      paymentItem.origin_amount = paymentItem.amount; // 保存原始金额
+      paymentItem.amount = '0.00'; // 将金额设为0，不参与订单金额计算
+
+      // 重新计算待付金额
       this.recalculateOrderAmount(order);
-      await this.dbManager.update("order", order);
+
+      // 更新到 IndexDB
+      await this.dbManager.update('order', order);
       await this.core.effects.emit(`${this.name}:onPaymentDeleted`, {
         order,
-        paymentItem
+        paymentItem: paymentItem
       });
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: "payment_delete",
+        action: 'payment_delete',
         order,
-        paymentItem
+        paymentItem: paymentItem
       });
-      this.logInfo("deletePaymentAsync completed successfully (marked as voided)", {
+      this.logInfo('deletePaymentAsync completed successfully (marked as voided)', {
         orderUuid,
         paymentUuid,
         originalAmount: paymentItem.origin_amount,
         newExpectAmount: order.expect_amount
       });
     } catch (error) {
-      console.error("[PaymentModule] 删除支付项失败", error);
-      this.logError("deletePaymentAsync failed", error, {
+      console.error('[PaymentModule] 删除支付项失败', error);
+      this.logError('deletePaymentAsync failed', error, {
         orderUuid,
         paymentUuid
       });
       throw error;
     }
   }
+
   /**
    * 批量更新代金券类支付项（覆盖更新）
    * 
@@ -674,12 +794,16 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    */
   async updateVoucherPaymentItemsAsync(orderUuid, voucherPaymentItems) {
     return this.runVoucherUpdateLocked(orderUuid, async () => {
-      const { items: normalizedVoucherItems, originalCount, normalizedCount } = this.normalizeVoucherPaymentItems(voucherPaymentItems);
-      this.logInfo("Starting updateVoucherPaymentItemsAsync", {
+      const {
+        items: normalizedVoucherItems,
+        originalCount,
+        normalizedCount
+      } = this.normalizeVoucherPaymentItems(voucherPaymentItems);
+      this.logInfo('Starting updateVoucherPaymentItemsAsync', {
         orderUuid,
         originalVoucherCount: originalCount,
         normalizedVoucherCount: normalizedCount,
-        voucherItems: normalizedVoucherItems.map((item) => ({
+        voucherItems: normalizedVoucherItems.map(item => ({
           code: item.code,
           amount: item.amount,
           voucher_id: item.voucher_id,
@@ -687,7 +811,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         }))
       });
       if (originalCount !== normalizedCount) {
-        console.warn("[PaymentModule] voucherPaymentItems detected duplicates (deduped by voucher_id + order_payment_type)", {
+        console.warn('[PaymentModule] voucherPaymentItems detected duplicates (deduped by voucher_id + order_payment_type)', {
           orderUuid,
           originalCount,
           normalizedCount
@@ -698,72 +822,52 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         if (!order) {
           throw new Error(`订单不存在: ${orderUuid}`);
         }
-        const existingVoucherItems = order.payment.filter(
-          (payment) => payment.voucher_id && payment.status !== "voided" && !payment.isSynced
-        );
-        console.log("[PaymentModule] 发现现有代金券支付项:", {
-          orderUuid,
-          existingVoucherCount: existingVoucherItems.length,
-          existingItems: existingVoucherItems.map((item) => ({
-            uuid: item.uuid,
-            code: item.code,
-            amount: item.amount,
-            voucher_id: item.voucher_id,
-            isSynced: item.isSynced
-          }))
-        });
+
+        // 1. 查找所有现有的代金券类支付项（带 voucher_id 且状态不是 voided)并且还没有同步给后端
+        // 如果同步给了后端的voucher 不允许删除
+        const existingVoucherItems = order.payment.filter(payment => payment.voucher_id && payment.status !== 'voided' && !payment.isSynced);
+        // 2. 删除所有现有的代金券支付项（仅删除未同步的）
         for (const voucherItem of existingVoucherItems) {
-          console.log(`[PaymentModule] 删除现有代金券支付项: ${voucherItem.uuid}`);
           await this.deletePaymentAsync(orderUuid, voucherItem.uuid);
         }
+
+        // 3. 添加新的代金券支付项（幂等：如果已存在同 voucher_id + order_payment_type 的 active 项则跳过）
         const orderAfterDelete = await this.getPaymentOrderByUuidAsync(orderUuid);
         if (!orderAfterDelete) {
           throw new Error(`订单不存在: ${orderUuid}`);
         }
-        const existingActiveVoucherKeys = new Set(
-          orderAfterDelete.payment.filter((p) => p.voucher_id && p.status !== "voided" && !p.isSynced).map((p) => `${p.voucher_id}|${p.order_payment_type || "normal"}`)
-        );
-        console.log("[PaymentModule] 添加新的代金券支付项:", {
-          orderUuid,
-          newItemCount: normalizedVoucherItems.length
-        });
+        const existingActiveVoucherKeys = new Set(orderAfterDelete.payment.filter(p => p.voucher_id && p.status !== 'voided' && !p.isSynced).map(p => `${p.voucher_id}|${p.order_payment_type || 'normal'}`));
         for (const voucherItem of normalizedVoucherItems) {
-          const orderPaymentType = voucherItem.order_payment_type || "normal";
+          const orderPaymentType = voucherItem.order_payment_type || 'normal';
           const key = `${voucherItem.voucher_id}|${orderPaymentType}`;
           if (existingActiveVoucherKeys.has(key)) {
-            console.warn("[PaymentModule] Skip adding voucher payment item because it already exists (active)", {
+            console.warn('[PaymentModule] Skip adding voucher payment item because it already exists (active)', {
               orderUuid,
               voucher_id: voucherItem.voucher_id,
               order_payment_type: orderPaymentType
             });
             continue;
           }
-          console.log(`[PaymentModule] 添加代金券支付项:`, {
-            ...voucherItem,
-            code: voucherItem.code,
-            amount: voucherItem.amount,
-            voucher_id: voucherItem.voucher_id,
-            order_payment_type: orderPaymentType
-          });
           await this.addPaymentItemAsync(orderUuid, voucherItem);
           existingActiveVoucherKeys.add(key);
         }
+
+        // 4. 触发支付项更新事件
         const updatedOrder = await this.getPaymentOrderByUuidAsync(orderUuid);
         await this.core.effects.emit(`${this.name}:onPaymentAdded`, {
           orderUuid,
           order: updatedOrder,
-          payment: null
-          // 批量操作不提供单个支付项
+          payment: null // 批量操作不提供单个支付项
         });
-        this.logInfo("updateVoucherPaymentItemsAsync completed successfully", {
+        this.logInfo('updateVoucherPaymentItemsAsync completed successfully', {
           orderUuid,
           removedVoucherCount: existingVoucherItems.length,
           addedVoucherCount: normalizedVoucherItems.length,
-          finalExpectAmount: updatedOrder == null ? void 0 : updatedOrder.expect_amount
+          finalExpectAmount: updatedOrder?.expect_amount
         });
       } catch (error) {
-        console.error("[PaymentModule] 批量更新代金券支付项失败:", error);
-        this.logError("updateVoucherPaymentItemsAsync failed", error, {
+        console.error('[PaymentModule] 批量更新代金券支付项失败:', error);
+        this.logError('updateVoucherPaymentItemsAsync failed', error, {
           orderUuid,
           voucherPaymentItems
         });
@@ -771,85 +875,100 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       }
     });
   }
+
   /**
    * 更新一个支付项
    */
   async updatePaymentAsync(orderUuid, paymentUuid, params) {
     try {
-      const order = await this.dbManager.get("order", orderUuid);
+      const order = await this.dbManager.get('order', orderUuid);
       if (!order) {
-        throw new Error("订单不存在");
+        throw new Error('订单不存在');
       }
-      const paymentItem = order.payment.find(
-        (payment) => payment.uuid === paymentUuid
-      );
+      const paymentItem = order.payment.find(payment => payment.uuid === paymentUuid);
       if (paymentItem) {
-        const formattedParams = { ...params };
-        if ("amount" in formattedParams && formattedParams.amount !== void 0) {
+        // 如果更新参数中包含 amount，先格式化
+        const formattedParams = {
+          ...params
+        };
+        if ('amount' in formattedParams && formattedParams.amount !== undefined) {
           formattedParams.amount = formatAmount(formattedParams.amount);
         }
-        if (formattedParams.metadata && typeof formattedParams.metadata === "object") {
+        if (formattedParams.metadata && typeof formattedParams.metadata === 'object') {
           formattedParams.metadata = {
-            ...paymentItem.metadata || {},
+            ...(paymentItem.metadata || {}),
             ...formattedParams.metadata
           };
         }
         Object.assign(paymentItem, formattedParams);
+
+        // 重新计算待付金额
         this.recalculateOrderAmount(order);
-        await this.dbManager.update("order", order);
+
+        // 更新到 IndexDB
+        await this.dbManager.update('order', order);
         await this.core.effects.emit(`${this.name}:onPaymentUpdated`, {
           order,
           paymentItem
         });
         await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-          action: "payment_update",
+          action: 'payment_update',
           order,
           paymentItem
         });
       }
     } catch (error) {
-      console.error("[PaymentModule] 更新支付项失败", error);
+      console.error('[PaymentModule] 更新支付项失败', error);
       throw error;
     }
   }
+
   /**
    * 提交支付
    */
   async submitPayAsync(orderUuid) {
-    this.logInfo("Starting submitPayAsync", { orderUuid });
+    this.logInfo('Starting submitPayAsync', {
+      orderUuid
+    });
     try {
       let orderToSubmit;
       if (orderUuid) {
-        const order = await this.dbManager.get("order", orderUuid);
+        const order = await this.dbManager.get('order', orderUuid);
         orderToSubmit = order ? [order] : [];
       } else {
-        const allOrders = await this.dbManager.getAll("order");
-        orderToSubmit = allOrders.filter(
-          (order) => order.payment_status === import_types.PaymentStatus.Processing || order.payment_status === import_types.PaymentStatus.PartiallyPaid
-        );
+        const allOrders = await this.dbManager.getAll('order');
+        // 包括正在处理中的订单和部分支付的订单（可能添加了新的支付项）
+        orderToSubmit = allOrders.filter(order => order.payment_status === _types.PaymentStatus.Processing || order.payment_status === _types.PaymentStatus.PartiallyPaid);
       }
       for (const order of orderToSubmit) {
         await this.submitSingleOrderPayment(order);
       }
-      const result = { status: "success" };
-      this.logInfo("submitPayAsync completed", {
+      const result = {
+        status: 'success'
+      };
+      this.logInfo('submitPayAsync completed', {
         result: result.status,
         processedOrdersCount: orderToSubmit.length
       });
       return result;
     } catch (error) {
-      console.error("[PaymentModule] 提交支付失败", error);
-      this.logError("submitPayAsync failed", error, { orderUuid });
-      return { status: "failed" };
+      console.error('[PaymentModule] 提交支付失败', error);
+      this.logError('submitPayAsync failed', error, {
+        orderUuid
+      });
+      return {
+        status: 'failed'
+      };
     }
   }
+
   /**
    * 提交单个订单的支付（推送到任务队列）
    */
   async submitSingleOrderPayment(order) {
     try {
       const paymentData = {
-        payments: order.payment.map((payment) => ({
+        payments: order.payment.map(payment => ({
           uuid: payment.uuid,
           payment_number: payment.payment_number,
           amount: payment.amount,
@@ -862,37 +981,41 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
           rounding_amount: payment.rounding_amount,
           service_charge: payment.service_charge
         })),
-        payment_status: "pending"
+        payment_status: 'pending'
       };
-      const totalPaidAmount = paymentData.payments.reduce(
-        (sum, payment) => sum.plus(payment.amount),
-        new import_decimal.Decimal(0)
-      );
-      const orderTotalAmount = new import_decimal.Decimal(order.total_amount);
+
+      // 计算总支付金额
+      const totalPaidAmount = paymentData.payments.reduce((sum, payment) => sum.plus(payment.amount), new _decimal.Decimal(0));
+      const orderTotalAmount = new _decimal.Decimal(order.total_amount);
+
+      // 根据支付金额判断订单状态
       if (totalPaidAmount.gte(orderTotalAmount)) {
-        order.payment_status = import_types.PaymentStatus.Finished;
-        console.log(
-          `[PaymentModule] 订单 ${order.uuid} 支付完成，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
-        );
+        // 支付金额足够，标记为已完成
+        order.payment_status = _types.PaymentStatus.Finished;
       } else {
-        order.payment_status = import_types.PaymentStatus.PartiallyPaid;
-        console.log(
-          `[PaymentModule] 订单 ${order.uuid} 部分支付，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
-        );
+        // 支付金额不足，标记为部分支付
+        order.payment_status = _types.PaymentStatus.PartiallyPaid;
       }
-      paymentData.payment_status = order.payment_status === import_types.PaymentStatus.Finished ? "paid" : "partially_paid";
-      await this.dbManager.update("order", order);
+
+      // 给后端标记一下是全部支付（paid）还是部分支付
+      paymentData.payment_status = order.payment_status === _types.PaymentStatus.Finished ? 'paid' : 'partially_paid';
+
+      // 更新订单状态到数据库
+      await this.dbManager.update('order', order);
+
+      // 检查支付列表是否为空
       if (paymentData.payments.length === 0) {
-        console.log(`[PaymentModule] 订单 ${order.uuid} 支付列表为空，跳过支付处理`);
-        this.logWarning("Empty payment list", {
+        this.logWarning('Empty payment list', {
           orderUuid: order.uuid,
           orderId: order.order_id
         });
         return;
       }
+
+      // 触发支付提交事件
       await this.core.effects.emit(`${this.name}:onPaymentSubmitted`, order);
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: "submit",
+        action: 'submit',
         order
       });
     } catch (error) {
@@ -900,170 +1023,165 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
+
   /**
    * 获取订单剩余待付金额
    */
   async getRemainingOrderAmountAsync(orderUuid) {
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
-      throw new Error("订单不存在");
+      throw new Error('订单不存在');
     }
-    return new import_decimal.Decimal(order.expect_amount).toNumber();
+    return new _decimal.Decimal(order.expect_amount).toNumber();
   }
+
   /**
    * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
    */
   async getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid) {
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
-      throw new Error("订单不存在");
+      throw new Error('订单不存在');
     }
-    if (inputAmount === null || inputAmount === void 0) {
-      return new import_decimal.Decimal(order.expect_amount).toNumber();
+
+    // 对输入金额做保护，确保是有效的数字
+    if (inputAmount === null || inputAmount === undefined) {
+      // 如果输入为空，返回原始的待付金额
+      return new _decimal.Decimal(order.expect_amount).toNumber();
     }
-    if (typeof inputAmount === "string") {
-      if (inputAmount.trim() === "") {
-        return new import_decimal.Decimal(order.expect_amount).toNumber();
+
+    // 处理字符串类型的输入
+    if (typeof inputAmount === 'string') {
+      if (inputAmount.trim() === '') {
+        // 如果输入为空字符串，返回原始的待付金额
+        return new _decimal.Decimal(order.expect_amount).toNumber();
       }
     }
-    if (typeof inputAmount === "number") {
+
+    // 处理数字类型的输入
+    if (typeof inputAmount === 'number') {
       if (isNaN(inputAmount) || !isFinite(inputAmount)) {
-        console.warn(
-          `[PaymentModule] 输入金额不是有效数字: ${inputAmount}，返回原始待付金额`
-        );
-        return new import_decimal.Decimal(order.expect_amount).toNumber();
+        // 如果输入是 NaN 或无穷大，返回原始的待付金额
+        console.warn(`[PaymentModule] 输入金额不是有效数字: ${inputAmount}，返回原始待付金额`);
+        return new _decimal.Decimal(order.expect_amount).toNumber();
       }
     }
     try {
-      const inputDecimal = new import_decimal.Decimal(inputAmount);
-      return new import_decimal.Decimal(order.expect_amount).minus(inputDecimal).toNumber();
+      const inputDecimal = new _decimal.Decimal(inputAmount);
+      return new _decimal.Decimal(order.expect_amount).minus(inputDecimal).toNumber();
     } catch (error) {
-      console.warn(
-        `[PaymentModule] 输入金额格式无效: ${inputAmount}，返回原始待付金额`
-      );
-      return new import_decimal.Decimal(order.expect_amount).toNumber();
+      // 如果输入不是有效的数字，返回原始的待付金额
+      console.warn(`[PaymentModule] 输入金额格式无效: ${inputAmount}，返回原始待付金额`);
+      return new _decimal.Decimal(order.expect_amount).toNumber();
     }
   }
+
   /**
    * 重新计算订单金额
    */
   recalculateOrderAmount(order) {
-    const totalAmount = new import_decimal.Decimal(order.total_amount);
-    const paidAmount = order.payment.reduce(
-      (sum, payment) => {
-        try {
-          if (payment.status === "voided") {
-            return sum;
-          }
-          const paymentAmount = new import_decimal.Decimal(payment.amount || 0);
-          const roundingAmount = new import_decimal.Decimal(payment.rounding_amount || 0);
-          const effectiveAmount = paymentAmount.minus(roundingAmount);
-          return sum.plus(effectiveAmount);
-        } catch (error) {
-          console.warn(`[PaymentModule] 无效的支付金额: amount=${payment.amount}, rounding_amount=${payment.rounding_amount}，跳过计算`);
+    const totalAmount = new _decimal.Decimal(order.total_amount);
+    const paidAmount = order.payment.reduce((sum, payment) => {
+      try {
+        // 忽略已撤销的支付项
+        if (payment.status === 'voided') {
           return sum;
         }
-      },
-      new import_decimal.Decimal(0)
-    );
-    const remainingAmount = order.is_deposit === 1 ? new import_decimal.Decimal(order.deposit_amount).minus(paidAmount) : totalAmount.minus(paidAmount);
-    order.expect_amount = import_decimal.Decimal.max(0, remainingAmount).toFixed(2);
-    console.log(`[PaymentModule] 重新计算订单金额:`, {
-      orderUuid: order.uuid,
-      totalAmount: order.total_amount,
-      effectivePaidAmount: paidAmount.toFixed(2),
-      remainingAmount: order.expect_amount,
-      activePayments: order.payment.filter((p) => p.status !== "voided").length,
-      voidedPayments: order.payment.filter((p) => p.status === "voided").length,
-      paymentDetails: order.payment.filter((p) => p.status !== "voided").map((p) => ({
-        code: p.code,
-        amount: p.amount,
-        rounding_amount: p.rounding_amount || "0.00",
-        effective_amount: new import_decimal.Decimal(p.amount || 0).minus(new import_decimal.Decimal(p.rounding_amount || 0)).toFixed(2)
-      })),
-      说明: "有效支付金额包含抹零计算（amount + |rounding_amount|）"
-    });
+
+        // 计算有效支付金额：支付金额 + 抹零金额的绝对值
+        // 当 rounding_amount 为负数时，表示抹掉的金额，按绝对值计算有效支付
+        // 例如：amount=15, rounding_amount=-0.2，有效支付=15.2（抹掉0.2元零头）
+        // 例2：amount=15,rounding_amount=0.2,有效支付 14.8 
+        const paymentAmount = new _decimal.Decimal(payment.amount || 0);
+        const roundingAmount = new _decimal.Decimal(payment.rounding_amount || 0);
+        const effectiveAmount = paymentAmount.minus(roundingAmount);
+        return sum.plus(effectiveAmount);
+      } catch (error) {
+        console.warn(`[PaymentModule] 无效的支付金额: amount=${payment.amount}, rounding_amount=${payment.rounding_amount}，跳过计算`);
+        return sum;
+      }
+    }, new _decimal.Decimal(0));
+    // 如果是定金模式，则使用deposit_amount 去减已付款金额
+    const remainingAmount = order.is_deposit === 1 ? new _decimal.Decimal(order.deposit_amount).minus(paidAmount) : totalAmount.minus(paidAmount);
+    order.expect_amount = _decimal.Decimal.max(0, remainingAmount).toFixed(2);
   }
+
   /**
    * 获取现金支付方式
    */
   async getCashPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll("pay_method");
-      return payMethods.find(
-        (method) => method.code === import_types.PaymentMethodType.Cash
-      ) || null;
+      const payMethods = await this.dbManager.getAll('pay_method');
+      return payMethods.find(method => method.code === _types.PaymentMethodType.Cash) || null;
     } catch (error) {
-      console.error("[PaymentModule] 获取现金支付方式失败", error);
+      console.error('[PaymentModule] 获取现金支付方式失败', error);
       return null;
     }
   }
+
   /**
    * 获取Eftpos支付方式
    */
   async getEftposPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll("pay_method");
-      return payMethods.find(
-        (method) => method.code === import_types.PaymentMethodType.Eftpos
-      ) || null;
+      const payMethods = await this.dbManager.getAll('pay_method');
+      return payMethods.find(method => method.code === _types.PaymentMethodType.Eftpos) || null;
     } catch (error) {
-      console.error("[PaymentModule] 获取Eftpos支付方式失败", error);
+      console.error('[PaymentModule] 获取Eftpos支付方式失败', error);
       return null;
     }
   }
+
   /**
    * 获取钱包支付方式
    */
   async getWalletPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll("pay_method");
-      return payMethods.find(
-        (method) => method.code === import_types.PaymentMethodType.Wallet
-      ) || null;
+      const payMethods = await this.dbManager.getAll('pay_method');
+      return payMethods.find(method => method.code === _types.PaymentMethodType.Wallet) || null;
     } catch (error) {
-      console.error("[PaymentModule] 获取钱包支付方式失败", error);
+      console.error('[PaymentModule] 获取钱包支付方式失败', error);
       return null;
     }
   }
+
   /**
    * 确保支付模块所需的数据库表已创建
    */
   /** @deprecated */
   async ensurePaymentTables() {
     try {
-      await this.dbManager.getAll("pay_method");
+      // 尝试访问 pay_method 表，如果不存在会抛出错误
+      await this.dbManager.getAll('pay_method');
     } catch (error) {
-      console.warn(
-        "[PaymentModule] pay_method 表不存在，请在数据库配置中添加以下配置："
-      );
+      console.warn('[PaymentModule] pay_method 表不存在，请在数据库配置中添加以下配置：');
       console.warn('{ name: "pay_method", keyPath: "id" }');
     }
     try {
-      await this.dbManager.getAll("order");
+      // 尝试访问 order 表，如果不存在会抛出错误
+      await this.dbManager.getAll('order');
     } catch (error) {
-      console.warn(
-        "[PaymentModule] order 表不存在，请在数据库配置中添加以下配置："
-      );
+      console.warn('[PaymentModule] order 表不存在，请在数据库配置中添加以下配置：');
       console.warn('{ name: "order", keyPath: "uuid" }');
     }
   }
+
   /**
    * 获取部分支付的订单
    */
   /** @deprecated */
   async getPartiallyPaidOrdersAsync() {
     try {
-      const allOrders = await this.dbManager.getAll("order");
-      return allOrders.filter(
-        (order) => order.payment_status === import_types.PaymentStatus.PartiallyPaid
-      );
+      const allOrders = await this.dbManager.getAll('order');
+      return allOrders.filter(order => order.payment_status === _types.PaymentStatus.PartiallyPaid);
     } catch (error) {
-      console.error("[PaymentModule] 获取部分支付订单失败", error);
+      console.error('[PaymentModule] 获取部分支付订单失败', error);
       return [];
     }
   }
+
   // === 新的 API 方法实现 ===
+
   /**
    * 智能金额舍入
    * 
@@ -1076,63 +1194,78 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    */
   async roundAmountAsync(originalAmount, interval, rule) {
     try {
-      const amount = new import_decimal.Decimal(originalAmount);
-      const roundingInterval = new import_decimal.Decimal(interval);
+      // 参数验证
+      const amount = new _decimal.Decimal(originalAmount);
+      const roundingInterval = new _decimal.Decimal(interval);
       if (roundingInterval.lte(0)) {
-        throw new Error("舍入间隔必须大于 0");
+        throw new Error('舍入间隔必须大于 0');
       }
+
+      // 支持的舍入间隔
       const supportedIntervals = [0.05, 0.1, 0.5, 1];
       const intervalValue = roundingInterval.toNumber();
       if (!supportedIntervals.includes(intervalValue)) {
-        console.warn(`[PaymentModule] 不支持的舍入间隔: ${intervalValue}, 支持的间隔: ${supportedIntervals.join(", ")}`);
+        console.warn(`[PaymentModule] 不支持的舍入间隔: ${intervalValue}, 支持的间隔: ${supportedIntervals.join(', ')}`);
       }
+
+      // 计算基础值：x / interval
       const baseValue = amount.div(roundingInterval);
-      console.log(`[PaymentModule] 舍入计算 - 原始金额: ${amount.toString()}, 间隔: ${intervalValue}, 基础值: ${baseValue.toString()}, 规则: ${rule}`);
       let roundedValue;
+
+      // 根据舍入规则处理
       switch (rule) {
-        case import_types.RoundingRule.Standard:
-        case "standard":
+        case _types.RoundingRule.Standard:
+        case 'standard':
+          // 标准舍入（中点向上）
           roundedValue = this.standardRound(baseValue, true);
           break;
-        case import_types.RoundingRule.StandardDown:
-        case "standard_rounding_midpoint_down":
+        case _types.RoundingRule.StandardDown:
+        case 'standard_rounding_midpoint_down':
+          // 标准舍入（中点向下）
           roundedValue = this.standardRound(baseValue, false);
           break;
-        case import_types.RoundingRule.AlwaysUp:
-        case "always_up":
+        case _types.RoundingRule.AlwaysUp:
+        case 'always_up':
+          // 总是向上舍入
           roundedValue = baseValue.ceil();
           break;
-        case import_types.RoundingRule.AlwaysDown:
-        case "always_down":
+        case _types.RoundingRule.AlwaysDown:
+        case 'always_down':
+          // 总是向下舍入
           roundedValue = baseValue.floor();
           break;
         default:
           throw new Error(`不支持的舍入规则: ${rule}`);
       }
+
+      // 计算最终金额：roundedValue * interval
       const finalAmount = roundedValue.mul(roundingInterval);
       const originalAmountStr = amount.toFixed(2);
+
+      // 如果最终金额是 0 元，则不采用舍入金额，返回原始金额
       if (finalAmount.eq(0)) {
-        console.log(`[PaymentModule] 最终金额为0，返回原始金额: ${originalAmountStr}`);
         return {
           originalAmount: originalAmountStr,
           roundedAmount: originalAmountStr,
-          roundingDifference: "0.00"
+          roundingDifference: '0.00'
         };
       }
       const roundedAmountStr = finalAmount.toFixed(2);
+
+      // 计算舍入差额
       const roundingDifference = finalAmount.sub(amount);
       const roundingDifferenceStr = roundingDifference.toFixed(2);
-      console.log(`[PaymentModule] 舍入结果 - 原始金额: ${originalAmountStr}, 舍入后金额: ${roundedAmountStr}, 舍入差额: ${roundingDifferenceStr}`);
       return {
         originalAmount: originalAmountStr,
         roundedAmount: roundedAmountStr,
         roundingDifference: roundingDifferenceStr
       };
     } catch (error) {
-      console.error("[PaymentModule] 金额舍入失败:", error);
+      console.error('[PaymentModule] 金额舍入失败:', error);
       throw new Error(`金额舍入失败: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+
   /**
    * 标准舍入处理（处理中点情况）
    * 
@@ -1143,18 +1276,18 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
   standardRound(value, midpointUp) {
     const floorValue = value.floor();
     const fractionalPart = value.minus(floorValue);
+
+    // 检查是否是中点（小数部分 = 0.5）
     if (fractionalPart.eq(0.5)) {
+      // 中点情况，根据规则决定
       return midpointUp ? floorValue.plus(1) : floorValue;
     } else if (fractionalPart.gt(0.5)) {
+      // 大于中点，向上舍入
       return floorValue.plus(1);
     } else {
+      // 小于中点，向下舍入
       return floorValue;
     }
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PaymentModule,
-  generateRequestUniqueId,
-  ...require("./types")
-});
+}
+exports.PaymentModule = PaymentModule;