@pisell/pisellos 0.0.230 → 0.0.232

package/lib/modules/Payment/index.js

@@ -29,7 +29,7 @@ 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_walletpass = require("./walletpass");
 var import_decimal = require("decimal.js");
 __reExport(Payment_exports, require("./types"), module.exports);
 function formatAmount(amount) {
@@ -60,7 +60,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     this.defaultVersion = "1.0.0";
     this.cash = new import_cash.CashPaymentImpl(this);
     this.eftpos = new import_eftpos.EftposPaymentImpl(this);
-    this.wallet = new import_wallet.WalletPaymentImpl(this);
+    this.wallet = new import_walletpass.WalletPassPaymentImpl(this);
   }
   async initialize(core, options) {
     this.core = core;
@@ -77,7 +77,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     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");
@@ -152,11 +151,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         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();
-        }
+        this.logInfo("Network reconnected");
       }
     });
   }
@@ -177,7 +172,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         this.refreshPaymentMethodsInBackground(cachedMethods);
         return cachedMethods;
       }
-      const response = await this.request.get("/pay/custom-payment/available");
+      const response = await this.request.get("/pay/custom-payment/available", { channel: "pos" });
       const payMethods = response.data || [];
       try {
         for (const method of payMethods) {
@@ -210,7 +205,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     });
     try {
       console.log("[PaymentModule] 后台刷新支付方式列表...");
-      const response = await this.request.get("/pay/custom-payment/available");
+      const response = await this.request.get("/pay/custom-payment/available", { channel: "pos" });
       const newPayMethods = response.data || [];
       const hasChanges = this.hasPaymentMethodsChanged(
         cachedMethods,
@@ -350,14 +345,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 往交易组中添加订单（兼容性方法）
-   * @deprecated 使用 createPaymentOrderAsync 替代
-   */
-  async pushOrderAsync(params) {
-    console.warn("[PaymentModule] pushOrderAsync 已废弃，请使用 createPaymentOrderAsync 替代");
-    return this.createPaymentOrderAsync(params);
-  }
   /**
    * 删除支付订单（新方法）
    */
@@ -374,14 +361,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 删除订单（兼容性方法）
-   * @deprecated 使用 deletePaymentOrderAsync 替代
-   */
-  async deleteOrderAsync(orderUuid) {
-    console.warn("[PaymentModule] deleteOrderAsync 已废弃，请使用 deletePaymentOrderAsync 替代");
-    return this.deletePaymentOrderAsync(orderUuid);
-  }
   /**
    * 更新订单
    */
@@ -439,6 +418,8 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       const updatedOrder = {
         ...existingOrder,
         id: newOrderId,
+        order_id: newOrderId,
+        // 🔧 修复：同时更新根级的 order_id 字段
         order_info: {
           ...existingOrder.order_info,
           order_id: newOrderId,
@@ -476,26 +457,36 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取支付项（新方法）
+   * 
+   * @param orderUuid 订单UUID
+   * @param includeVoided 是否包含已撤销的支付项，默认为false
+   * @returns 支付项数组
    */
-  async getPaymentItemsAsync(orderUuid) {
+  async getPaymentItemsAsync(orderUuid, includeVoided = false) {
     if (!orderUuid) {
       throw new Error("orderUuid is required");
     }
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
-    return (order == null ? void 0 : order.payment) || [];
+    const allPayments = (order == null ? void 0 : order.payment) || [];
+    if (includeVoided) {
+      return allPayments;
+    }
+    return allPayments.filter((payment) => payment.status !== "voided");
   }
   /**
-   * 获取支付项（兼容性方法）
-   * @deprecated 使用 getPaymentItemsAsync 替代
+   * 获取所有支付项（包括已撤销的）
+   * 
+   * @param orderUuid 订单UUID
+   * @returns 所有支付项数组（包括撤销的）
    */
-  async getPaymentAsync(orderUuid) {
-    console.warn("[PaymentModule] getPaymentAsync 已废弃，请使用 getPaymentItemsAsync 替代");
-    return this.getPaymentItemsAsync(orderUuid);
+  async getAllPaymentItemsAsync(orderUuid) {
+    return this.getPaymentItemsAsync(orderUuid, true);
   }
   /**
    * 为某个订单添加支付项（新方法）
    */
   async addPaymentItemAsync(orderUuid, paymentItem) {
+    var _a;
     this.logInfo("Starting addPaymentItemAsync", {
       orderUuid,
       paymentAmount: paymentItem.amount,
@@ -506,8 +497,9 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       if (!order) {
         throw new Error(`Order not found: ${orderUuid}`);
       }
+      const paymentUuid = (0, import_utils.getUniqueId)("payment_");
       const newPaymentItem = {
-        uuid: (0, import_utils.getUniqueId)("payment_"),
+        uuid: paymentUuid,
         id: paymentItem.id || 0,
         name: paymentItem.name,
         code: paymentItem.code,
@@ -515,8 +507,13 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         amount: formatAmount(paymentItem.amount),
         voucher_id: paymentItem.voucher_id || "",
         rounding_amount: "0.00",
-        service_charge: { percentage: "0.00", amount: "0.00" },
-        isSynced: false
+        service_charge: paymentItem.service_charge,
+        status: "active",
+        // 新支付项默认为活跃状态
+        metadata: {
+          unique_payment_number: paymentUuid
+          // 设置唯一支付号为支付项的 uuid
+        }
       };
       order.payment.push(newPaymentItem);
       this.recalculateOrderAmount(order);
@@ -528,6 +525,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       this.logInfo("addPaymentItemAsync completed successfully", {
         orderUuid,
         paymentUuid: newPaymentItem.uuid,
+        uniquePaymentNumber: (_a = newPaymentItem.metadata) == null ? void 0 : _a.unique_payment_number,
         newExpectAmount: order.expect_amount
       });
     } catch (error) {
@@ -540,42 +538,131 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 为某个订单设置一个支付项（兼容性方法）
-   * @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 });
+    this.logInfo("Starting deletePaymentAsync (mark as voided)", { orderUuid, paymentUuid });
     try {
       const order = await this.dbManager.get("order", orderUuid);
       if (!order) {
         throw new Error("订单不存在");
       }
-      const index = order.payment.findIndex(
+      const paymentItem = order.payment.find(
         (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
-        });
+      if (!paymentItem) {
+        throw new Error(`支付项不存在: ${paymentUuid}`);
+      }
+      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
+      });
+      this.recalculateOrderAmount(order);
+      await this.dbManager.update("order", order);
+      await this.core.effects.emit(import_types.PaymentHooks.OnPaymentDeleted, {
+        order,
+        paymentItem
+      });
+      await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
+        action: "payment_delete",
+        order,
+        paymentItem
+      });
+      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, {
+        orderUuid,
+        paymentUuid
+      });
+      throw error;
+    }
+  }
+  /**
+   * 批量更新代金券类支付项（覆盖更新）
+   * 
+   * 删除所有现有的带 voucher_id 的支付项，然后添加新的代金券支付项
+   * 这是一个覆盖式更新，确保代金券支付项的一致性
+   */
+  async updateVoucherPaymentItemsAsync(orderUuid, voucherPaymentItems) {
+    this.logInfo("Starting updateVoucherPaymentItemsAsync", {
+      orderUuid,
+      newVoucherCount: voucherPaymentItems.length,
+      voucherItems: voucherPaymentItems.map((item) => ({
+        code: item.code,
+        amount: item.amount,
+        voucher_id: item.voucher_id
+      }))
+    });
+    try {
+      const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+      if (!order) {
+        throw new Error(`订单不存在: ${orderUuid}`);
+      }
+      const existingVoucherItems = order.payment.filter(
+        (payment) => payment.voucher_id && payment.status !== "voided"
+      );
+      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
+        }))
+      });
+      for (const voucherItem of existingVoucherItems) {
+        console.log(`[PaymentModule] 删除现有代金券支付项: ${voucherItem.uuid}`);
+        await this.deletePaymentAsync(orderUuid, voucherItem.uuid);
+      }
+      console.log("[PaymentModule] 添加新的代金券支付项:", {
+        orderUuid,
+        newItemCount: voucherPaymentItems.length
+      });
+      for (const voucherItem of voucherPaymentItems) {
+        if (!voucherItem.voucher_id) {
+          throw new Error(`代金券支付项缺少 voucher_id: ${JSON.stringify(voucherItem)}`);
+        }
+        console.log(`[PaymentModule] 添加代金券支付项:`, {
+          code: voucherItem.code,
+          amount: voucherItem.amount,
+          voucher_id: voucherItem.voucher_id
+        });
+        await this.addPaymentItemAsync(orderUuid, voucherItem);
+      }
+      const updatedOrder = await this.getPaymentOrderByUuidAsync(orderUuid);
+      await this.core.effects.emit(import_types.PaymentHooks.OnPaymentAdded, {
+        orderUuid,
+        order: updatedOrder,
+        payment: null
+        // 批量操作不提供单个支付项
+      });
+      this.logInfo("updateVoucherPaymentItemsAsync completed successfully", {
+        orderUuid,
+        removedVoucherCount: existingVoucherItems.length,
+        addedVoucherCount: voucherPaymentItems.length,
+        finalExpectAmount: updatedOrder == null ? void 0 : updatedOrder.expect_amount
+      });
+    } catch (error) {
+      console.error("[PaymentModule] 批量更新代金券支付项失败:", error);
+      this.logError("updateVoucherPaymentItemsAsync failed", error, {
+        orderUuid,
+        voucherPaymentItems
+      });
       throw error;
     }
   }
@@ -625,32 +712,20 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         const order = await this.dbManager.get("order", orderUuid);
         orderToSubmit = order ? [order] : [];
       } else {
-        const allOrders2 = await this.dbManager.getAll("order");
-        orderToSubmit = allOrders2.filter(
+        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
         );
       }
       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" };
-      }
+      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 });
@@ -696,14 +771,13 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       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", {
+        console.log(`[PaymentModule] 订单 ${order.uuid} 支付列表为空，跳过支付处理`);
+        this.logWarning("Empty payment list", {
           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",
@@ -714,39 +788,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       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);
-    }
-  }
   /**
    * 获取订单剩余待付金额
    */
@@ -799,6 +840,9 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     const paidAmount = order.payment.reduce(
       (sum, payment) => {
         try {
+          if (payment.status === "voided") {
+            return sum;
+          }
           return sum.plus(payment.amount);
         } catch (error) {
           console.warn(`[PaymentModule] 无效的支付金额: ${payment.amount}，跳过计算`);
@@ -809,6 +853,14 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     );
     const remainingAmount = totalAmount.minus(paidAmount);
     order.expect_amount = import_decimal.Decimal.max(0, remainingAmount).toFixed(2);
+    console.log(`[PaymentModule] 重新计算订单金额:`, {
+      orderUuid: order.uuid,
+      totalAmount: order.total_amount,
+      paidAmount: 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
+    });
   }
   /**
    * 获取现金支付方式
@@ -852,189 +904,6 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       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
-        };
-      }
-    }
-  }
   /**
    * 确保支付模块所需的数据库表已创建
    */
@@ -1070,249 +939,79 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       return [];
     }
   }
+  // === 新的 API 方法实现 ===
   /**
-   * 获取未同步到服务器的订单
-   */
-  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();
-   * ```
+   * 智能金额舍入
+   * 
+   * 根据指定的舍入间隔和规则对金额进行舍入处理
+   * 
+   * @param originalAmount 原始金额
+   * @param interval 舍入间隔 (0.05, 0.1, 0.5, 1)
+   * @param rule 舍入规则 (standard, standard_down, always_up, always_down)
+   * @returns 舍入后的金额（保留两位小数的字符串）
    */
-  async runPaymentSyncQueue() {
-    this.logInfo("Starting runPaymentSyncQueue");
+  async roundAmountAsync(originalAmount, interval, rule) {
     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");
+      const amount = new import_decimal.Decimal(originalAmount);
+      const roundingInterval = new import_decimal.Decimal(interval);
+      if (roundingInterval.lte(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(", ")}`);
+      }
+      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":
+          roundedValue = this.standardRound(baseValue, true);
+          break;
+        case import_types.RoundingRule.StandardDown:
+        case "standard_down":
+          roundedValue = this.standardRound(baseValue, false);
+          break;
+        case import_types.RoundingRule.AlwaysUp:
+        case "always_up":
+          roundedValue = baseValue.ceil();
+          break;
+        case import_types.RoundingRule.AlwaysDown:
+        case "always_down":
+          roundedValue = baseValue.floor();
+          break;
+        default:
+          throw new Error(`不支持的舍入规则: ${rule}`);
+      }
+      const finalAmount = roundedValue.mul(roundingInterval);
+      const result = finalAmount.toFixed(2);
+      console.log(`[PaymentModule] 舍入结果 - 舍入值: ${roundedValue.toString()}, 最终金额: ${result}`);
+      return result;
     } catch (error) {
-      console.error("[PaymentModule] 执行支付同步队列失败", error);
-      this.logError("runPaymentSyncQueue failed", error);
+      console.error("[PaymentModule] 金额舍入失败:", error);
+      throw new Error(`金额舍入失败: ${error instanceof Error ? error.message : String(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;
+   * 标准舍入处理（处理中点情况）
+   * 
+   * @param value 要舍入的值
+   * @param midpointUp 中点是否向上舍入
+   * @returns 舍入后的值
+   */
+  standardRound(value, midpointUp) {
+    const floorValue = value.floor();
+    const fractionalPart = value.minus(floorValue);
+    if (fractionalPart.eq(0.5)) {
+      return midpointUp ? floorValue.plus(1) : floorValue;
+    } else if (fractionalPart.gt(0.5)) {
+      return floorValue.plus(1);
+    } else {
+      return floorValue;
     }
   }
-  // === 新的 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 = {