@pisell/pisellos 3.0.56 → 3.0.57

package/lib/modules/Payment/index.js

@@ -14,74 +14,1309 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+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
+  PaymentModule: () => PaymentModule,
+  generateRequestUniqueId: () => generateRequestUniqueId
 });
 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_wallet = require("./wallet");
+var import_decimal = require("decimal.js");
+__reExport(Payment_exports, require("./types"), module.exports);
+function formatAmount(amount) {
+  try {
+    const decimal = new import_decimal.Decimal(amount);
+    return decimal.toFixed(2);
+  } catch (error) {
+    console.warn(`[PaymentModule] 金额格式化失败: ${amount}，使用默认值 0.00`);
+    return "0.00";
+  }
+}
+function generateRequestUniqueId() {
+  const now = /* @__PURE__ */ 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;
+  return `${year}${month}${day}${hour}${minute}${second}${millisecond}${randomDigits}`;
+}
 var PaymentModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
-    this.defaultName = "bookingByStep";
+    this.defaultName = "pay";
     this.defaultVersion = "1.0.0";
-    this.state = {
-      currentPayment: null,
-      paymentHistory: []
-    };
+    this.cash = new import_cash.CashPaymentImpl(this);
+    this.eftpos = new import_eftpos.EftposPaymentImpl(this);
+    this.wallet = new import_wallet.WalletPaymentImpl(this);
   }
   async initialize(core, options) {
     this.core = core;
-    if (options == null ? void 0 : options.initialState) {
-      this.state = { ...this.state, ...options.initialState };
-    }
-  }
-  // async initPayment(order: OrderModule, method: PaymentMethod) {
-  // const payment: Payment = {}
-  // this.state.currentPayment = payment
-  // await this.core.effects.emit(PaymentHooks.OnPaymentInit, payment)
-  // return payment
-  // }
-  async processPayment(paymentId) {
-    const payment = this.state.paymentHistory.find((p) => p.id === paymentId);
-    if (!payment)
-      return;
-    payment.status = "processing";
-    payment.updatedAt = /* @__PURE__ */ new Date();
-    await this.core.effects.emit(import_types.PaymentHooks.OnPaymentSuccess, payment);
-  }
-  async getPayment(paymentId) {
-    const payment = this.state.paymentHistory.find((p) => p.id === paymentId);
-    if (!payment)
-      throw new Error("Payment not found");
-    return payment;
-  }
-  async getPaymentHistory() {
-    return this.state.paymentHistory;
-  }
-  async refund(paymentId) {
-    const payment = this.state.paymentHistory.find((p) => p.id === paymentId);
-    if (!payment)
-      return;
-    payment.status = "refunded";
-    payment.updatedAt = /* @__PURE__ */ new Date();
-    await this.core.effects.emit(import_types.PaymentHooks.OnPaymentRefund, payment);
-  }
-  getAvailablePaymentMethods() {
-    return ["credit_card", "debit_card", "alipay", "wechat_pay"];
-  }
-  async checkPaymentStatus(paymentId) {
-    const payment = this.state.paymentHistory.find((p) => p.id === paymentId);
-    if (!payment)
-      throw new Error("Payment not found");
-    return payment.status;
+    this.store = options.store;
+    this.request = core.getPlugin("request");
+    const appPlugin = core.getPlugin("app");
+    if (!this.request) {
+      throw new Error("支付模块需要 request 插件支持");
+    }
+    if (!appPlugin) {
+      throw new Error("支付模块需要 app 插件支持");
+    }
+    this.app = appPlugin.getApp();
+    this.dbManager = this.app.dbManager;
+    this.logger = this.app.logger;
+    await this.ensurePaymentTables();
+    this.registerTaskHandlers();
+    this.registerNetworkHandlers();
+    console.log("[PaymentModule] 初始化完成");
+    this.logInfo("PaymentModule initialized successfully");
+  }
+  /**
+   * 记录信息日志
+   */
+  logInfo(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "info",
+        title: `[PaymentModule] ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  /**
+   * 记录警告日志
+   */
+  logWarning(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "warning",
+        title: `[PaymentModule] ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  /**
+   * 记录错误日志
+   */
+  logError(title, error, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "error",
+        title: `[PaymentModule] ${title}`,
+        metadata: {
+          error: error ? {
+            message: error.message,
+            stack: error.stack,
+            code: error.code,
+            ...error
+          } : void 0,
+          ...metadata || {}
+        }
+      });
+    }
+  }
+  /**
+   * 记录调试日志
+   */
+  logDebug(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        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", {
+        connected: status.connected,
+        previousStatus: status.previousStatus
+      });
+      if (status.connected) {
+        this.logInfo("Network reconnected - triggering payment sync queue");
+        const requeuedCount = await this.recheckAndRequeueUnsyncedOrders();
+        if (requeuedCount > 0) {
+          await this.runPaymentSyncQueue();
+        }
+      }
+    });
+  }
+  /**
+   * 获取支付方式列表
+   */
+  async getPayMethodListAsync() {
+    this.logInfo("Starting getPayMethodListAsync");
+    try {
+      let cachedMethods = [];
+      try {
+        cachedMethods = await this.dbManager.getAll("pay_method");
+      } catch (dbError) {
+        console.warn("[PaymentModule] pay_method 表不存在，将从服务器获取数据");
+      }
+      const hasCache = cachedMethods.length > 0;
+      if (hasCache) {
+        this.refreshPaymentMethodsInBackground(cachedMethods);
+        return cachedMethods;
+      }
+      const response = await this.request.get("/pay/custom-payment/available");
+      const payMethods = response.data || [];
+      try {
+        for (const method of payMethods) {
+          await this.dbManager.update("pay_method", method);
+        }
+      } catch (dbError) {
+        console.warn("[PaymentModule] 无法缓存支付方式，pay_method 表不存在");
+      }
+      await this.core.effects.emit(
+        import_types.PaymentHooks.OnPaymentMethodsLoaded,
+        payMethods
+      );
+      this.logInfo("getPayMethodListAsync completed successfully", {
+        methodCount: payMethods.length,
+        hasCache: cachedMethods.length > 0
+      });
+      return payMethods;
+    } catch (error) {
+      console.error("[PaymentModule] 获取支付方式列表失败", error);
+      this.logError("getPayMethodListAsync failed", error);
+      return [];
+    }
+  }
+  /**
+   * 后台刷新支付方式列表
+   */
+  async refreshPaymentMethodsInBackground(cachedMethods) {
+    this.logInfo("Starting refreshPaymentMethodsInBackground", {
+      cachedMethodsCount: cachedMethods.length
+    });
+    try {
+      console.log("[PaymentModule] 后台刷新支付方式列表...");
+      const response = await this.request.get("/pay/custom-payment/available");
+      const newPayMethods = response.data || [];
+      const hasChanges = this.hasPaymentMethodsChanged(
+        cachedMethods,
+        newPayMethods
+      );
+      if (hasChanges) {
+        console.log("[PaymentModule] 支付方式列表已更新");
+        this.logInfo("Payment methods updated in background", {
+          oldCount: cachedMethods.length,
+          newCount: newPayMethods.length
+        });
+        try {
+          for (const method of cachedMethods) {
+            await this.dbManager.delete("pay_method", method.id);
+          }
+          for (const method of newPayMethods) {
+            await this.dbManager.update("pay_method", method);
+          }
+        } catch (dbError) {
+          console.warn("[PaymentModule] 无法更新支付方式缓存", dbError);
+        }
+        const eventData = {
+          oldMethods: cachedMethods,
+          newMethods: newPayMethods
+        };
+        await this.core.effects.emit(
+          import_types.PaymentHooks.OnPaymentMethodsChanged,
+          eventData
+        );
+      } else {
+        console.log("[PaymentModule] 支付方式列表无变化");
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 后台刷新支付方式失败", error);
+    }
+  }
+  /**
+   * 检查支付方式列表是否有变化
+   */
+  hasPaymentMethodsChanged(oldMethods, newMethods) {
+    if (oldMethods.length !== newMethods.length) {
+      return true;
+    }
+    const oldMethodsMap = new Map(
+      oldMethods.map((method) => [method.id, method])
+    );
+    for (const newMethod of newMethods) {
+      const oldMethod = oldMethodsMap.get(newMethod.id);
+      if (!oldMethod) {
+        return true;
+      }
+      if (oldMethod.code !== newMethod.code || oldMethod.name !== newMethod.name || oldMethod.type !== newMethod.type || oldMethod.enabled !== newMethod.enabled) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 获取订单列表
+   */
+  async getOrderListAsync() {
+    try {
+      return await this.dbManager.getAll("order");
+    } catch (error) {
+      console.error("[PaymentModule] 获取订单列表失败", error);
+      return [];
+    }
+  }
+  /**
+   * 根据订单UUID获取支付订单（新方法）
+   */
+  async getPaymentOrderByUuidAsync(orderUuid) {
+    try {
+      return await this.dbManager.get("order", orderUuid);
+    } catch (error) {
+      console.error("[PaymentModule] 获取支付订单失败", error);
+      return null;
+    }
+  }
+  /**
+   * 创建支付订单（新方法，专注支付数据）
+   */
+  async createPaymentOrderAsync(params) {
+    this.logInfo("Starting createPaymentOrderAsync", {
+      orderId: params.order_id,
+      totalAmount: params.total_amount
+    });
+    try {
+      const existingOrders = await this.dbManager.getAll("order");
+      const existingOrder = existingOrders.find(
+        (order) => String(order.id) === String(params.order_id)
+      );
+      if (existingOrder) {
+        console.log(
+          `[PaymentModule] 发现重复订单 ID: ${params.order_id}，更新现有支付订单`
+        );
+        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);
+        await this.core.effects.emit(
+          import_types.PaymentHooks.OnOrderUpdated,
+          existingOrder
+        );
+        return existingOrder;
+      } else {
+        const newOrder = {
+          uuid: (0, import_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: [],
+          adjust_offline_payments: [],
+          total_amount: params.total_amount,
+          expect_amount: params.total_amount,
+          tax_fee: "0.00",
+          is_deposit: params.is_deposit || 0,
+          deposit_amount: params.deposit_amount || "0.00"
+        };
+        await this.dbManager.add("order", newOrder);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderAdded, newOrder);
+        this.logInfo("createPaymentOrderAsync completed - new payment order created", {
+          orderUuid: newOrder.uuid,
+          orderId: newOrder.id
+        });
+        return newOrder;
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 创建支付订单失败", error);
+      this.logError("createPaymentOrderAsync failed", error, {
+        orderId: params.order_id
+      });
+      throw error;
+    }
+  }
+  /**
+   * 往交易组中添加订单（兼容性方法）
+   * @deprecated 使用 createPaymentOrderAsync 替代
+   */
+  async pushOrderAsync(params) {
+    console.warn("[PaymentModule] pushOrderAsync 已废弃，请使用 createPaymentOrderAsync 替代");
+    return this.createPaymentOrderAsync(params);
+  }
+  /**
+   * 删除支付订单（新方法）
+   */
+  async deletePaymentOrderAsync(orderUuid) {
+    try {
+      const order = await this.dbManager.get("order", orderUuid);
+      if (order) {
+        await this.dbManager.delete("order", orderUuid);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderDeleted, order);
+        console.log("[PaymentModule] 支付订单删除成功:", orderUuid);
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 删除支付订单失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 删除订单（兼容性方法）
+   * @deprecated 使用 deletePaymentOrderAsync 替代
+   */
+  async deleteOrderAsync(orderUuid) {
+    console.warn("[PaymentModule] deleteOrderAsync 已废弃，请使用 deletePaymentOrderAsync 替代");
+    return this.deletePaymentOrderAsync(orderUuid);
+  }
+  /**
+   * 更新订单
+   */
+  async updateOrderAsync(orderUuid, params) {
+    try {
+      const order = await this.dbManager.get("order", orderUuid);
+      if (order) {
+        const updatedOrder = { ...order, ...params };
+        await this.dbManager.update("order", updatedOrder);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderUpdated, updatedOrder);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "update",
+          order: updatedOrder,
+          originalOrder: order
+        });
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 更新订单失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 基于UUID替换订单ID
+   * 
+   * 此方法用于将本地虚拟订单ID替换为真实的订单ID。
+   * 当前端模拟下单流程完成后，后端返回真实订单ID时调用此方法。
+   * 
+   * @param orderUuid 订单的UUID
+   * @param newOrderId 新的订单ID (来自后端)
+   * @returns 更新后的订单对象，如果订单不存在则返回null
+   */
+  async replaceOrderIdByUuidAsync(orderUuid, newOrderId) {
+    this.logInfo("Starting replaceOrderIdByUuidAsync", {
+      orderUuid,
+      newOrderId
+    });
+    try {
+      const existingOrder = await this.dbManager.get("order", orderUuid);
+      if (!existingOrder) {
+        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
+      );
+      if (duplicateOrder) {
+        this.logWarning("New order ID already exists", {
+          newOrderId,
+          existingOrderUuid: duplicateOrder.uuid
+        });
+        throw new Error(`订单ID ${newOrderId} 已存在`);
+      }
+      const originalOrderId = existingOrder.id;
+      const updatedOrder = {
+        ...existingOrder,
+        id: newOrderId,
+        order_info: {
+          ...existingOrder.order_info,
+          order_id: newOrderId,
+          // 保留原始本地订单ID作为参考
+          original_local_order_id: originalOrderId,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      await this.dbManager.update("order", updatedOrder);
+      await this.core.effects.emit(import_types.PaymentHooks.OnOrderUpdated, updatedOrder);
+      await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+        action: "order_id_replaced",
+        order: updatedOrder,
+        originalOrder: existingOrder,
+        metadata: {
+          originalOrderId,
+          newOrderId
+        }
+      });
+      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, {
+        orderUuid,
+        newOrderId
+      });
+      throw error;
+    }
+  }
+  /**
+   * 获取支付项（新方法）
+   */
+  async getPaymentItemsAsync(orderUuid) {
+    if (!orderUuid) {
+      throw new Error("orderUuid is required");
+    }
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+    return (order == null ? void 0 : order.payment) || [];
+  }
+  /**
+   * 获取支付项（兼容性方法）
+   * @deprecated 使用 getPaymentItemsAsync 替代
+   */
+  async getPaymentAsync(orderUuid) {
+    console.warn("[PaymentModule] getPaymentAsync 已废弃，请使用 getPaymentItemsAsync 替代");
+    return this.getPaymentItemsAsync(orderUuid);
+  }
+  /**
+   * 为某个订单添加支付项（新方法）
+   */
+  async addPaymentItemAsync(orderUuid, paymentItem) {
+    this.logInfo("Starting addPaymentItemAsync", {
+      orderUuid,
+      paymentAmount: paymentItem.amount,
+      paymentCode: paymentItem.code
+    });
+    try {
+      const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+      if (!order) {
+        throw new Error(`Order not found: ${orderUuid}`);
+      }
+      const newPaymentItem = {
+        uuid: (0, import_utils.getUniqueId)("payment_"),
+        id: paymentItem.id || 0,
+        name: paymentItem.name,
+        code: paymentItem.code,
+        type: paymentItem.type,
+        amount: formatAmount(paymentItem.amount),
+        voucher_id: paymentItem.voucher_id || "",
+        rounding_amount: "0.00",
+        service_charge: { percentage: "0.00", amount: "0.00" },
+        isSynced: false
+      };
+      order.payment.push(newPaymentItem);
+      this.recalculateOrderAmount(order);
+      await this.dbManager.update("order", order);
+      await this.core.effects.emit(import_types.PaymentHooks.OnPaymentAdded, {
+        orderUuid,
+        payment: newPaymentItem
+      });
+      this.logInfo("addPaymentItemAsync completed successfully", {
+        orderUuid,
+        paymentUuid: newPaymentItem.uuid,
+        newExpectAmount: order.expect_amount
+      });
+    } catch (error) {
+      console.error("[PaymentModule] 添加支付项失败", error);
+      this.logError("addPaymentItemAsync failed", error, {
+        orderUuid,
+        paymentItem
+      });
+      throw error;
+    }
+  }
+  /**
+   * 为某个订单设置一个支付项（兼容性方法）
+   * @deprecated 使用 addPaymentItemAsync 替代
+   */
+  async pushPaymentAsync(orderUuid, paymentItem) {
+    console.warn("[PaymentModule] pushPaymentAsync 已废弃，请使用 addPaymentItemAsync 替代");
+    return this.addPaymentItemAsync(orderUuid, paymentItem);
+  }
+  /**
+   * 删除一个支付项
+   */
+  async deletePaymentAsync(orderUuid, paymentUuid) {
+    this.logInfo("Starting deletePaymentAsync", { orderUuid, paymentUuid });
+    try {
+      const order = await this.dbManager.get("order", orderUuid);
+      if (!order) {
+        throw new Error("订单不存在");
+      }
+      const index = order.payment.findIndex(
+        (payment) => payment.uuid === paymentUuid
+      );
+      if (index > -1) {
+        const deletedPayment = order.payment.splice(index, 1)[0];
+        this.recalculateOrderAmount(order);
+        await this.dbManager.update("order", order);
+        await this.core.effects.emit(import_types.PaymentHooks.OnPaymentDeleted, {
+          order,
+          paymentItem: deletedPayment
+        });
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "payment_delete",
+          order,
+          paymentItem: deletedPayment
+        });
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 删除支付项失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 更新一个支付项
+   */
+  async updatePaymentAsync(orderUuid, paymentUuid, params) {
+    try {
+      const order = await this.dbManager.get("order", orderUuid);
+      if (!order) {
+        throw new Error("订单不存在");
+      }
+      const paymentItem = order.payment.find(
+        (payment) => payment.uuid === paymentUuid
+      );
+      if (paymentItem) {
+        const formattedParams = { ...params };
+        if ("amount" in formattedParams && formattedParams.amount !== void 0) {
+          formattedParams.amount = formatAmount(formattedParams.amount);
+        }
+        Object.assign(paymentItem, formattedParams);
+        this.recalculateOrderAmount(order);
+        await this.dbManager.update("order", order);
+        await this.core.effects.emit(import_types.PaymentHooks.OnPaymentUpdated, {
+          order,
+          paymentItem
+        });
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "payment_update",
+          order,
+          paymentItem
+        });
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 更新支付项失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 提交支付
+   */
+  async submitPayAsync(orderUuid) {
+    this.logInfo("Starting submitPayAsync", { orderUuid });
+    try {
+      let orderToSubmit;
+      if (orderUuid) {
+        const order = await this.dbManager.get("order", orderUuid);
+        orderToSubmit = order ? [order] : [];
+      } else {
+        const allOrders2 = await this.dbManager.getAll("order");
+        orderToSubmit = allOrders2.filter(
+          (order) => order.payment_status === import_types.PaymentStatus.Processing || order.payment_status === import_types.PaymentStatus.PartiallyPaid
+        );
+      }
+      for (const order of orderToSubmit) {
+        await this.submitSingleOrderPayment(order);
+      }
+      await this.runPaymentSyncQueue();
+      const allOrders = await this.dbManager.getAll("order");
+      const allOrdersProcessed = allOrders.every(
+        (order) => order.payment.every((payment) => payment.isSynced === true)
+      );
+      if (allOrdersProcessed) {
+        const result = { status: "success" };
+        this.logInfo("submitPayAsync completed", {
+          result: result.status,
+          processedOrdersCount: allOrders.length
+        });
+        return result;
+      } else {
+        this.logWarning("submitPayAsync completed with unprocessed orders", {
+          totalOrders: allOrders.length
+        });
+        return { status: "failed" };
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 提交支付失败", error);
+      this.logError("submitPayAsync failed", error, { orderUuid });
+      return { status: "failed" };
+    }
+  }
+  /**
+   * 提交单个订单的支付（推送到任务队列）
+   */
+  async submitSingleOrderPayment(order) {
+    try {
+      const paymentData = {
+        payments: order.payment.map((payment) => ({
+          uuid: payment.uuid,
+          amount: payment.amount,
+          code: payment.code,
+          id: payment.id,
+          name: payment.name,
+          type: payment.type,
+          voucher_id: payment.voucher_id,
+          metadata: payment.metadata,
+          rounding_amount: payment.rounding_amount,
+          service_charge: payment.service_charge
+        })),
+        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);
+      if (totalPaidAmount.gte(orderTotalAmount)) {
+        order.payment_status = import_types.PaymentStatus.Finished;
+        console.log(
+          `[PaymentModule] 订单 ${order.uuid} 支付完成，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
+        );
+      } else {
+        order.payment_status = import_types.PaymentStatus.PartiallyPaid;
+        console.log(
+          `[PaymentModule] 订单 ${order.uuid} 部分支付，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
+        );
+      }
+      paymentData.payment_status = order.payment_status === import_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 queue submission", {
+          orderUuid: order.uuid,
+          orderId: order.order_id
+        });
+        return;
+      }
+      await this.addToSyncQueue(order, paymentData);
+      await this.core.effects.emit(import_types.PaymentHooks.OnPaymentSubmitted, order);
+      await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+        action: "submit",
+        order
+      });
+    } catch (error) {
+      console.error(`[PaymentModule] 订单 ${order.uuid} 支付提交失败`, error);
+      throw error;
+    }
+  }
+  /**
+   * 添加到同步任务队列
+   */
+  async addToSyncQueue(order, paymentData) {
+    try {
+      console.log(`[PaymentModule] 订单 ${order.uuid} 已添加到同步队列`);
+      if (this.app.tasksManager) {
+        this.app.tasksManager.addTask({
+          module: "payment",
+          queueId: "payment_sync",
+          tasks: [
+            {
+              id: `payment_${order.uuid}`,
+              action: "syncPayment",
+              payload: {
+                orderUuid: order.uuid,
+                orderId: order.order_id,
+                paymentData,
+                core: this.core
+              },
+              maxRetries: 3,
+              type: "cloud"
+            }
+          ]
+        });
+        console.log(`[PaymentModule] 订单 ${order.uuid} 同步任务已添加到队列`);
+      } else {
+        console.warn("[PaymentModule] TasksManager 未初始化，无法添加同步任务");
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 添加同步任务失败", error);
+    }
+  }
+  /**
+   * 获取订单剩余待付金额
+   */
+  async getRemainingOrderAmountAsync(orderUuid) {
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+    if (!order) {
+      throw new Error("订单不存在");
+    }
+    return new import_decimal.Decimal(order.expect_amount).toNumber();
+  }
+  /**
+   * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
+   */
+  async getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid) {
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+    if (!order) {
+      throw new Error("订单不存在");
+    }
+    if (inputAmount === null || inputAmount === void 0) {
+      return new import_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 === "number") {
+      if (isNaN(inputAmount) || !isFinite(inputAmount)) {
+        console.warn(
+          `[PaymentModule] 输入金额不是有效数字: ${inputAmount}，返回原始待付金额`
+        );
+        return new import_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();
+    } catch (error) {
+      console.warn(
+        `[PaymentModule] 输入金额格式无效: ${inputAmount}，返回原始待付金额`
+      );
+      return new import_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 {
+          return sum.plus(payment.amount);
+        } catch (error) {
+          console.warn(`[PaymentModule] 无效的支付金额: ${payment.amount}，跳过计算`);
+          return sum;
+        }
+      },
+      new import_decimal.Decimal(0)
+    );
+    const remainingAmount = totalAmount.minus(paidAmount);
+    order.expect_amount = import_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;
+    } catch (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;
+    } catch (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;
+    } catch (error) {
+      console.error("[PaymentModule] 获取钱包支付方式失败", error);
+      return null;
+    }
+  }
+  /**
+   * 注册任务处理函数
+   */
+  registerTaskHandlers() {
+    if (this.app.tasksManager) {
+      this.app.tasksManager.addTaskFunction(
+        "syncPayment",
+        PaymentModule.syncPaymentTask
+      );
+      console.log("[PaymentModule] 任务处理函数已注册");
+    } else {
+      console.warn(
+        "[PaymentModule] TasksManager 未初始化，无法注册任务处理函数"
+      );
+    }
+  }
+  /**
+   * 静态方法：处理支付同步任务（后台网络同步）
+   * 这个方法里不允许用 this，因为需要作为静态方法注入到任务队列里
+   */
+  static async syncPaymentTask(payload) {
+    var _a, _b, _c, _d, _e, _f;
+    const { orderUuid, orderId, paymentData, core } = payload.task.payload;
+    console.log(`[PaymentModule] 开始后台同步支付，订单ID: ${orderId}`);
+    paymentData.request_unique = generateRequestUniqueId();
+    const app = window.app;
+    const logger = app == null ? void 0 : app.logger;
+    if (logger) {
+      logger.addLog({
+        type: "info",
+        title: "[PaymentModule] Starting syncPaymentTask",
+        metadata: {
+          orderUuid,
+          orderId,
+          paymentDataKeys: Object.keys(paymentData)
+        }
+      });
+    }
+    if (!app) {
+      throw new Error("App 实例未找到");
+    }
+    const request = app.request;
+    if (!request) {
+      throw new Error("Request 插件未找到");
+    }
+    const dbManager = app.dbManager;
+    if (!dbManager) {
+      throw new Error("DBManager 未找到");
+    }
+    try {
+      const requestRes = await request.post(
+        `/shop/order/${orderId}/order-payment`,
+        paymentData,
+        { noToast: true }
+      );
+      if (requestRes.status === true) {
+        const order = await dbManager.get("order", orderUuid);
+        if (order) {
+          order.payment.forEach((payment) => {
+            payment.isSynced = true;
+            delete payment.syncError;
+          });
+          await dbManager.update("order", order);
+          console.log(`[PaymentModule] 订单 ${orderUuid} 同步状态已更新`);
+        }
+        console.log(`[PaymentModule] 订单 ${orderUuid} 后台同步成功`);
+        await core.effects.emit("payment:onPaymentSyncSuccess", {
+          orderUuid,
+          orderId,
+          timestamp: Date.now()
+        });
+        console.log(
+          `[PaymentModule] 已通过 effects 通知前端订单 ${orderUuid} 同步成功`
+        );
+        if (logger) {
+          logger.addLog({
+            type: "info",
+            title: "[PaymentModule] syncPaymentTask completed successfully",
+            metadata: { orderUuid, orderId }
+          });
+        }
+        return { status: "success", orderUuid, orderId };
+      } else {
+        console.log(`[PaymentModule] 接口返回失败，订单 ${orderUuid} 同步失败`);
+        const businessError = new Error(requestRes.message || "接口返回失败");
+        businessError.response = { status: 200 };
+        businessError.isBusinessError = true;
+        businessError.responseData = requestRes;
+        throw businessError;
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 后台同步失败:", error);
+      const isNetworkError = !error.response && !error.status && (error.code === "NETWORK_ERROR" || error.code === "ERR_NETWORK" || error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ETIMEDOUT" || ((_a = error.message) == null ? void 0 : _a.includes("网络")) || ((_b = error.message) == null ? void 0 : _b.includes("network")) || ((_c = error.message) == null ? void 0 : _c.includes("fetch")));
+      if (isNetworkError) {
+        console.log(`[PaymentModule] 网络错误，订单 ${orderUuid} 将重试同步`);
+        if (logger) {
+          logger.addLog({
+            type: "warning",
+            title: "[PaymentModule] syncPaymentTask network error - will retry",
+            metadata: {
+              orderUuid,
+              orderId,
+              errorCode: error.code,
+              errorMessage: error.message
+            }
+          });
+        }
+        throw error;
+      } else {
+        console.log(
+          `[PaymentModule] 业务错误，订单 ${orderUuid} 同步失败，通知前端`
+        );
+        try {
+          if (core && core.effects) {
+            const errorData = {
+              orderUuid,
+              orderId,
+              error: error.message || "业务错误",
+              errorCode: error.code,
+              statusCode: ((_d = error.response) == null ? void 0 : _d.status) || error.status,
+              timestamp: Date.now()
+            };
+            if (error.isBusinessError && error.responseData) {
+              errorData.error = error.responseData.message || error.message || "接口返回失败";
+              errorData.responseData = error.responseData;
+            }
+            await core.effects.emit("payment:onPaymentSyncError", errorData);
+            console.log(
+              `[PaymentModule] 已通过 effects 通知前端订单 ${orderUuid} 同步错误`
+            );
+          } else {
+            console.warn(
+              `[PaymentModule] 无法获取 core 实例，无法通知前端错误`
+            );
+          }
+          if (logger) {
+            logger.addLog({
+              type: "error",
+              title: "[PaymentModule] syncPaymentTask business error",
+              metadata: {
+                orderUuid,
+                orderId,
+                errorCode: error.code,
+                errorMessage: error.message,
+                statusCode: ((_e = error.response) == null ? void 0 : _e.status) || error.status,
+                isBusinessError: error.isBusinessError
+              }
+            });
+          }
+        } catch (notifyError) {
+          console.error(`[PaymentModule] 通知前端同步错误失败:`, notifyError);
+          if (logger) {
+            logger.addLog({
+              type: "error",
+              title: "[PaymentModule] Failed to notify frontend of sync error",
+              metadata: {
+                orderUuid,
+                orderId,
+                notifyError: notifyError instanceof Error ? notifyError.message : String(notifyError)
+              }
+            });
+          }
+        }
+        const order = await dbManager.get("order", orderUuid);
+        if (order) {
+          order.payment.forEach((payment) => {
+            payment.isSynced = true;
+          });
+          await dbManager.update("order", order);
+          console.log(
+            `[PaymentModule] 订单 ${orderUuid} 业务错误，已标记为已同步`
+          );
+        }
+        return {
+          status: "completed_with_error",
+          orderUuid,
+          orderId,
+          error: error.message || "业务错误",
+          statusCode: ((_f = error.response) == null ? void 0 : _f.status) || error.status
+        };
+      }
+    }
+  }
+  /**
+   * 确保支付模块所需的数据库表已创建
+   */
+  async ensurePaymentTables() {
+    try {
+      await this.dbManager.getAll("pay_method");
+    } catch (error) {
+      console.warn(
+        "[PaymentModule] pay_method 表不存在，请在数据库配置中添加以下配置："
+      );
+      console.warn('{ name: "pay_method", keyPath: "id" }');
+    }
+    try {
+      await this.dbManager.getAll("order");
+    } catch (error) {
+      console.warn(
+        "[PaymentModule] order 表不存在，请在数据库配置中添加以下配置："
+      );
+      console.warn('{ name: "order", keyPath: "uuid" }');
+    }
+  }
+  /**
+   * 获取部分支付的订单
+   */
+  async getPartiallyPaidOrdersAsync() {
+    try {
+      const allOrders = await this.dbManager.getAll("order");
+      return allOrders.filter(
+        (order) => order.payment_status === import_types.PaymentStatus.PartiallyPaid
+      );
+    } catch (error) {
+      console.error("[PaymentModule] 获取部分支付订单失败", error);
+      return [];
+    }
+  }
+  /**
+   * 获取未同步到服务器的订单
+   */
+  async getUnsyncedOrdersAsync() {
+    try {
+      const allOrders = await this.dbManager.getAll("order");
+      return allOrders.filter((order) => {
+        return (order.payment_status === import_types.PaymentStatus.Finished || order.payment_status === import_types.PaymentStatus.PartiallyPaid) && order.payment.some((payment) => !payment.isSynced);
+      });
+    } catch (error) {
+      console.error("[PaymentModule] 获取未同步订单失败", error);
+      return [];
+    }
+  }
+  /**
+   * 清理已完成且已同步的订单
+   * 注意：只清理完全支付的订单，部分支付的订单保留以便继续支付
+   */
+  async cleanupFinishedOrders() {
+    try {
+      const allOrders = await this.dbManager.getAll("order");
+      const finishedAndSyncedOrders = allOrders.filter(
+        (order) => order.payment_status === import_types.PaymentStatus.Finished && order.payment.every((payment) => payment.isSynced)
+      );
+      for (const order of finishedAndSyncedOrders) {
+        await this.deleteOrderAsync(order.uuid);
+      }
+      console.log(
+        `[PaymentModule] 清理了 ${finishedAndSyncedOrders.length} 个已完成且已同步的订单`
+      );
+    } catch (error) {
+      console.error("[PaymentModule] 清理已完成订单失败", error);
+    }
+  }
+  /**
+   * 检测未同步的订单并重新加入任务队列
+   *
+   * 此方法专门用于处理因网络问题导致任务队列执行失败但队列被清空的情况。
+   * 它会检查本地 IndexDB 中所有未同步的订单（isSynced: false），
+   * 并将这些订单重新添加到任务队列中。
+   *
+   * 使用场景：
+   * - 网络恢复后重新检查未同步的订单
+   * - 应用启动时检查并重新排队未完成的支付
+   * - 用户手动重试前的预检查
+   *
+   * @returns Promise<number> 返回重新加入队列的订单数量
+   */
+  async recheckAndRequeueUnsyncedOrders() {
+    this.logInfo("Starting recheckAndRequeueUnsyncedOrders");
+    try {
+      if (!this.app.tasksManager) {
+        console.warn(
+          "[PaymentModule] TasksManager 未初始化，无法重新排队未同步订单"
+        );
+        this.logWarning(
+          "TasksManager not initialized, cannot requeue unsynced orders"
+        );
+        return 0;
+      }
+      const unsyncedOrders = await this.getUnsyncedOrdersAsync();
+      if (unsyncedOrders.length === 0) {
+        console.log("[PaymentModule] 没有发现未同步的订单");
+        this.logInfo("No unsynced orders found");
+        return 0;
+      }
+      console.log(
+        `[PaymentModule] 发现 ${unsyncedOrders.length} 个未同步的订单，开始重新加入任务队列`
+      );
+      this.logInfo("Found unsynced orders, adding to sync queue", {
+        unsyncedCount: unsyncedOrders.length,
+        orderUuids: unsyncedOrders.map((o) => o.uuid)
+      });
+      let requeuedCount = 0;
+      for (const order of unsyncedOrders) {
+        const success = await this.reAddOrderToSyncQueue(order);
+        if (success) {
+          requeuedCount++;
+        }
+      }
+      console.log(
+        `[PaymentModule] 成功重新加入 ${requeuedCount} 个订单到任务队列`
+      );
+      this.logInfo("Successfully requeued unsynced orders", {
+        requeuedCount,
+        totalFound: unsyncedOrders.length
+      });
+      return requeuedCount;
+    } catch (error) {
+      console.error("[PaymentModule] 重新排队未同步订单失败", error);
+      this.logError("recheckAndRequeueUnsyncedOrders failed", error);
+      return 0;
+    }
+  }
+  /**
+   * 手动执行支付同步队列
+   * 外部可以调用此方法来触发支付同步任务的执行
+   *
+   * 注意：此方法只执行现有队列中的任务，不会检查未同步的订单。
+   * 如果需要检查未同步订单，请先调用 recheckAndRequeueUnsyncedOrders()
+   *
+   * 使用示例：
+   * ```typescript
+   * // 1. 先检查并重新排队未同步订单，然后执行队列
+   * const requeuedCount = await paymentModule.recheckAndRequeueUnsyncedOrders();
+   * if (requeuedCount > 0) {
+   *   await paymentModule.runPaymentSyncQueue();
+   * }
+   *
+   * // 2. 或者直接执行现有队列（不检查未同步订单）
+   * await paymentModule.runPaymentSyncQueue();
+   * ```
+   */
+  async runPaymentSyncQueue() {
+    this.logInfo("Starting runPaymentSyncQueue");
+    try {
+      if (!this.app.tasksManager) {
+        console.warn("[PaymentModule] TasksManager 未初始化，无法执行同步队列");
+        this.logWarning("TasksManager not initialized, cannot run sync queue");
+        return;
+      }
+      const queue = this.app.tasksManager.getTaskQueue({
+        module: "payment",
+        queueId: "payment_sync"
+      });
+      if (!(queue == null ? void 0 : queue.length)) {
+        console.log("[PaymentModule] 支付同步队列无内容，不执行");
+        return;
+      }
+      console.log("[PaymentModule] 开始执行支付同步队列");
+      await this.app.tasksManager.run({
+        module: "payment",
+        queueId: "payment_sync",
+        callback: () => {
+          console.log("[PaymentModule] 支付同步队列执行完成");
+          if (this.logger) {
+            this.logger.addLog({
+              type: "info",
+              title: "[PaymentModule] Payment sync queue completed",
+              metadata: {}
+            });
+          }
+        }
+      });
+      this.logInfo("runPaymentSyncQueue completed successfully");
+    } catch (error) {
+      console.error("[PaymentModule] 执行支付同步队列失败", error);
+      this.logError("runPaymentSyncQueue failed", error);
+    }
+  }
+  /**
+   * 重新将订单添加到同步队列
+   * 用于处理因网络问题导致任务队列清空但订单未同步的情况
+   *
+   * @param order 要重新添加的订单
+   * @returns Promise<boolean> 是否成功添加到队列
+   */
+  async reAddOrderToSyncQueue(order) {
+    try {
+      const paymentData = {
+        payments: order.payment.map((payment) => ({
+          uuid: payment.uuid,
+          amount: payment.amount,
+          code: payment.code,
+          id: payment.id,
+          name: payment.name,
+          type: payment.type,
+          voucher_id: payment.voucher_id,
+          metadata: payment.metadata,
+          rounding_amount: payment.rounding_amount,
+          service_charge: payment.service_charge
+        })),
+        payment_status: order.payment_status === import_types.PaymentStatus.Finished ? "paid" : "partially_paid"
+      };
+      const existingQueue = this.app.tasksManager.getTaskQueue({
+        module: "payment",
+        queueId: "payment_sync"
+      });
+      const taskId = `payment_${order.uuid}`;
+      const taskExists = existingQueue == null ? void 0 : existingQueue.some((task) => task.id === taskId);
+      if (taskExists) {
+        console.log(
+          `[PaymentModule] 任务 ${taskId} 已存在于队列中，跳过重复添加`
+        );
+        return false;
+      }
+      await this.addToSyncQueue(order, paymentData);
+      console.log(`[PaymentModule] 订单 ${order.uuid} 已重新添加到同步队列`);
+      this.logInfo("Order re-added to sync queue", {
+        orderUuid: order.uuid,
+        orderId: order.order_id,
+        paymentStatus: order.payment_status,
+        unsyncedPayments: order.payment.filter((p) => !p.isSynced).length
+      });
+      return true;
+    } catch (error) {
+      console.error(
+        `[PaymentModule] 重新添加订单 ${order.uuid} 到同步队列失败`,
+        error
+      );
+      this.logError("Failed to re-add order to sync queue", error, {
+        orderUuid: order.uuid,
+        orderId: order.order_id
+      });
+      return false;
+    }
+  }
+  // === 新的 API 方法实现 ===
+  /**
+   * 删除支付项（新方法）
+   */
+  async deletePaymentItemAsync(orderUuid, paymentUuid) {
+    console.warn("[PaymentModule] deletePaymentItemAsync 暂时使用 deletePaymentAsync 实现");
+    return this.deletePaymentAsync(orderUuid, paymentUuid);
+  }
+  /**
+   * 更新支付项（新方法）
+   */
+  async updatePaymentItemAsync(orderUuid, paymentUuid, params) {
+    console.warn("[PaymentModule] updatePaymentItemAsync 暂时使用 updatePaymentAsync 实现");
+    return this.updatePaymentAsync(orderUuid, paymentUuid, params);
+  }
+  /**
+   * 获取订单剩余待付金额（新方法）
+   */
+  async getRemainingAmountAsync(orderUuid) {
+    console.warn("[PaymentModule] getRemainingAmountAsync 暂时使用 getRemainingOrderAmountAsync 实现");
+    return this.getRemainingOrderAmountAsync(orderUuid);
+  }
+  /**
+   * 获取订单剩余待付金额（基于用户输入的金额）（新方法）
+   */
+  async getRemainingAmountWithInputAsync(inputAmount, orderUuid) {
+    console.warn("[PaymentModule] getRemainingAmountWithInputAsync 暂时使用 getRemainingOrderAmountWithInputAsync 实现");
+    return this.getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid);
+  }
+  /**
+   * 提交支付（新方法）
+   */
+  async submitPaymentAsync(orderUuid) {
+    console.warn("[PaymentModule] submitPaymentAsync 暂时使用 submitPayAsync 实现");
+    return this.submitPayAsync(orderUuid);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PaymentModule
+  PaymentModule,
+  generateRequestUniqueId,
+  ...require("./types")
 });