@pisell/pisellos 0.0.192 → 0.0.194

package/lib/modules/Payment/index.js

@@ -14,6 +14,7 @@ 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
@@ -24,64 +25,976 @@ __export(Payment_exports, {
 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";
+  }
+}
 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.usePlugin("network");
+    this.logInfo("Registering network status listener");
+    network == null ? void 0 : network.addListener("networkStatusChange", (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");
+        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 getOrderByUuidAsync(orderUuid) {
+    try {
+      return await this.dbManager.get("order", orderUuid);
+    } catch (error) {
+      console.error("[PaymentModule] 获取订单失败", error);
+      return null;
+    }
+  }
+  /**
+   * 往交易组中添加订单
+   */
+  async pushOrderAsync(params) {
+    this.logInfo("Starting pushOrderAsync", {
+      orderId: params.order_info.order_id,
+      totalAmount: params.order_info.total_amount
+    });
+    try {
+      const existingOrders = await this.dbManager.getAll("order");
+      const existingOrder = existingOrders.find(
+        (order) => order.id === params.order_info.order_id
+      );
+      if (existingOrder) {
+        console.log(
+          `[PaymentModule] 发现重复订单 ID: ${params.order_info.order_id}，更新现有订单`
+        );
+        const originalOrder = { ...existingOrder };
+        existingOrder.order_info = params.order_info;
+        existingOrder.total_amount = params.order_info.total_amount;
+        this.recalculateOrderAmount(existingOrder);
+        await this.dbManager.update("order", existingOrder);
+        await this.core.effects.emit(
+          import_types.PaymentHooks.OnOrderUpdated,
+          existingOrder
+        );
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "update",
+          order: existingOrder,
+          originalOrder
+        });
+        return existingOrder;
+      } else {
+        const newOrder = {
+          uuid: (0, import_utils.getUniqueId)("pay_order_"),
+          id: params.order_info.order_id,
+          order_info: params.order_info,
+          payment_status: import_types.PaymentStatus.Processing,
+          payment: [],
+          adjust_offline_payments: [],
+          total_amount: params.order_info.total_amount,
+          expect_amount: params.order_info.total_amount,
+          tax_fee: "0.00"
+        };
+        await this.dbManager.add("order", newOrder);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderAdded, newOrder);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "add",
+          order: newOrder
+        });
+        this.logInfo("pushOrderAsync completed - new order created", {
+          orderUuid: newOrder.uuid,
+          orderId: newOrder.id
+        });
+        return newOrder;
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 添加订单失败", error);
+      this.logError("pushOrderAsync failed", error, {
+        orderId: params.order_info.order_id
+      });
+      throw error;
+    }
+  }
+  /**
+   * 删除订单
+   */
+  async deleteOrderAsync(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);
+        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+          action: "delete",
+          order
+        });
+      }
+    } catch (error) {
+      console.error("[PaymentModule] 删除订单失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 更新订单
+   */
+  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;
+    }
+  }
+  /**
+   * 获取支付项
+   */
+  async getPaymentAsync(orderUuid) {
+    if (!orderUuid) {
+      throw new Error("orderUuid is required");
+    }
+    const order = await this.getOrderByUuidAsync(orderUuid);
+    return (order == null ? void 0 : order.payment) || [];
+  }
+  /**
+   * 为某个订单设置一个支付项
+   */
+  async pushPaymentAsync(orderUuid, paymentItem) {
+    this.logInfo("Starting pushPaymentAsync", {
+      orderUuid,
+      paymentAmount: paymentItem.amount,
+      paymentCode: paymentItem.code
+    });
+    try {
+      const order = await this.dbManager.get("order", orderUuid);
+      if (!order) {
+        throw new Error("订单不存在");
+      }
+      const newPaymentItem = {
+        ...paymentItem,
+        amount: formatAmount(paymentItem.amount),
+        // 格式化金额为保留两位小数的字符串
+        uuid: (0, import_utils.getUniqueId)("pay_item_"),
+        isSynced: false
+      };
+      order.payment.push(newPaymentItem);
+      this.recalculateOrderAmount(order);
+      await this.dbManager.update("order", order);
+      await this.core.effects.emit(import_types.PaymentHooks.OnPaymentAdded, {
+        order,
+        paymentItem: newPaymentItem
+      });
+      await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+        action: "payment_add",
+        order,
+        paymentItem: newPaymentItem
+      });
+      this.logInfo("pushPaymentAsync completed successfully", {
+        orderUuid,
+        paymentUuid: newPaymentItem.uuid,
+        newExpectAmount: order.expect_amount
+      });
+    } catch (error) {
+      console.error("[PaymentModule] 添加支付项失败", error);
+      this.logError("pushPaymentAsync failed", error, {
+        orderUuid,
+        paymentItem
+      });
+      throw error;
+    }
+  }
+  /**
+   * 删除一个支付项
+   */
+  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) => payment),
+        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.order_info.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);
+      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_info.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.getOrderByUuidAsync(orderUuid);
+    if (!order) {
+      throw new Error("订单不存在");
+    }
+    return new import_decimal.Decimal(order.expect_amount).toNumber();
+  }
+  /**
+   * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
+   */
+  async getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid) {
+    const order = await this.getOrderByUuidAsync(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.order_info.total_amount);
+    const paidAmount = order.payment.reduce(
+      (sum, payment) => sum.plus(payment.amount),
+      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}`);
+    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);
+    }
+  }
+  /**
+   * 手动执行支付同步队列
+   * 外部可以调用此方法来触发支付同步任务的执行
+   */
+  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;
+      }
+      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);
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PaymentModule
+  PaymentModule,
+  ...require("./types")
 });