@pisell/pisellos 0.0.229 → 0.0.231

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,
@@ -280,96 +275,89 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 根据uuid获取指定订单
+   * 根据订单UUID获取支付订单（新方法）
    */
-  async getOrderByUuidAsync(orderUuid) {
+  async getPaymentOrderByUuidAsync(orderUuid) {
     try {
       return await this.dbManager.get("order", orderUuid);
     } catch (error) {
-      console.error("[PaymentModule] 获取订单失败", 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
+  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) => order.id === params.order_info.order_id
+        (order) => String(order.id) === String(params.order_id)
       );
       if (existingOrder) {
         console.log(
-          `[PaymentModule] 发现重复订单 ID: ${params.order_info.order_id}，更新现有订单`
+          `[PaymentModule] 发现重复订单 ID: ${params.order_id}，更新现有支付订单`
         );
         const originalOrder = { ...existingOrder };
         existingOrder.order_info = params.order_info;
-        existingOrder.total_amount = params.order_info.total_amount;
+        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
         );
-        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,
+          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.order_info.total_amount,
-          expect_amount: params.order_info.total_amount,
-          tax_fee: "0.00"
+          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);
-        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
-          action: "add",
-          order: newOrder
-        });
-        this.logInfo("pushOrderAsync completed - new order created", {
+        this.logInfo("createPaymentOrderAsync completed - new payment 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
+      console.error("[PaymentModule] 创建支付订单失败", error);
+      this.logError("createPaymentOrderAsync failed", error, {
+        orderId: params.order_id
       });
       throw error;
     }
   }
   /**
-   * 删除订单
+   * 删除支付订单（新方法）
    */
-  async deleteOrderAsync(orderUuid) {
+  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);
-        await this.core.effects.emit(import_types.PaymentHooks.OnOrderChanged, {
-          action: "delete",
-          order
-        });
+        console.log("[PaymentModule] 支付订单删除成功:", orderUuid);
       }
     } catch (error) {
-      console.error("[PaymentModule] 删除订单失败", error);
+      console.error("[PaymentModule] 删除支付订单失败", error);
       throw error;
     }
   }
@@ -395,56 +383,154 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 获取支付项
+   * 基于UUID替换订单ID
+   * 
+   * 此方法用于将本地虚拟订单ID替换为真实的订单ID。
+   * 当前端模拟下单流程完成后，后端返回真实订单ID时调用此方法。
+   * 
+   * @param orderUuid 订单的UUID
+   * @param newOrderId 新的订单ID (来自后端)
+   * @returns 更新后的订单对象，如果订单不存在则返回null
    */
-  async getPaymentAsync(orderUuid) {
+  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_id: newOrderId,
+        // 🔧 修复：同时更新根级的 order_id 字段
+        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;
+    }
+  }
+  /**
+   * 获取支付项（新方法）
+   * 
+   * @param orderUuid 订单UUID
+   * @param includeVoided 是否包含已撤销的支付项，默认为false
+   * @returns 支付项数组
+   */
+  async getPaymentItemsAsync(orderUuid, includeVoided = false) {
     if (!orderUuid) {
       throw new Error("orderUuid is required");
     }
-    const order = await this.getOrderByUuidAsync(orderUuid);
-    return (order == null ? void 0 : order.payment) || [];
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
+    const allPayments = (order == null ? void 0 : order.payment) || [];
+    if (includeVoided) {
+      return allPayments;
+    }
+    return allPayments.filter((payment) => payment.status !== "voided");
+  }
+  /**
+   * 获取所有支付项（包括已撤销的）
+   * 
+   * @param orderUuid 订单UUID
+   * @returns 所有支付项数组（包括撤销的）
+   */
+  async getAllPaymentItemsAsync(orderUuid) {
+    return this.getPaymentItemsAsync(orderUuid, true);
   }
   /**
-   * 为某个订单设置一个支付项
+   * 为某个订单添加支付项（新方法）
    */
-  async pushPaymentAsync(orderUuid, paymentItem) {
-    this.logInfo("Starting pushPaymentAsync", {
+  async addPaymentItemAsync(orderUuid, paymentItem) {
+    var _a;
+    this.logInfo("Starting addPaymentItemAsync", {
       orderUuid,
       paymentAmount: paymentItem.amount,
       paymentCode: paymentItem.code
     });
     try {
-      const order = await this.dbManager.get("order", orderUuid);
+      const order = await this.getPaymentOrderByUuidAsync(orderUuid);
       if (!order) {
-        throw new Error("订单不存在");
+        throw new Error(`Order not found: ${orderUuid}`);
       }
+      const paymentUuid = (0, import_utils.getUniqueId)("payment_");
       const newPaymentItem = {
-        ...paymentItem,
+        uuid: paymentUuid,
+        id: paymentItem.id || 0,
+        name: paymentItem.name,
+        code: paymentItem.code,
+        type: paymentItem.type,
         amount: formatAmount(paymentItem.amount),
-        // 格式化金额为保留两位小数的字符串
-        uuid: (0, import_utils.getUniqueId)("pay_item_"),
-        isSynced: false
+        voucher_id: paymentItem.voucher_id || "",
+        rounding_amount: "0.00",
+        service_charge: paymentItem.service_charge,
+        status: "active",
+        // 新支付项默认为活跃状态
+        metadata: {
+          unique_payment_number: paymentUuid
+          // 设置唯一支付号为支付项的 uuid
+        }
       };
       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
+        orderUuid,
+        payment: newPaymentItem
       });
-      this.logInfo("pushPaymentAsync completed successfully", {
+      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) {
       console.error("[PaymentModule] 添加支付项失败", error);
-      this.logError("pushPaymentAsync failed", error, {
+      this.logError("addPaymentItemAsync failed", error, {
         orderUuid,
         paymentItem
       });
@@ -452,34 +538,131 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 删除一个支付项
+   * 删除一个支付项 - 标记删除而非物理删除
    */
   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;
     }
   }
@@ -529,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 });
@@ -585,7 +756,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         (sum, payment) => sum.plus(payment.amount),
         new import_decimal.Decimal(0)
       );
-      const orderTotalAmount = new import_decimal.Decimal(order.order_info.total_amount);
+      const orderTotalAmount = new import_decimal.Decimal(order.total_amount);
       if (totalPaidAmount.gte(orderTotalAmount)) {
         order.payment_status = import_types.PaymentStatus.Finished;
         console.log(
@@ -600,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_info.order_id
+          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",
@@ -618,44 +788,11 @@ 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_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);
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
       throw new Error("订单不存在");
     }
@@ -665,7 +802,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
    */
   async getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid) {
-    const order = await this.getOrderByUuidAsync(orderUuid);
+    const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
       throw new Error("订单不存在");
     }
@@ -699,13 +836,31 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    * 重新计算订单金额
    */
   recalculateOrderAmount(order) {
-    const totalAmount = new import_decimal.Decimal(order.order_info.total_amount);
+    const totalAmount = new import_decimal.Decimal(order.total_amount);
     const paidAmount = order.payment.reduce(
-      (sum, payment) => sum.plus(payment.amount),
+      (sum, payment) => {
+        try {
+          if (payment.status === "voided") {
+            return sum;
+          }
+          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);
+    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
+    });
   }
   /**
    * 获取现金支付方式
@@ -749,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
-        };
-      }
-    }
-  }
   /**
    * 确保支付模块所需的数据库表已创建
    */
@@ -967,211 +939,77 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       return [];
     }
   }
+  // === 新的 API 方法实现 ===
   /**
-   * 获取未同步到服务器的订单
+   * 智能金额舍入
+   * 
+   * 根据指定的舍入间隔和规则对金额进行舍入处理
+   * 
+   * @param originalAmount 原始金额
+   * @param interval 舍入间隔 (0.05, 0.1, 0.5, 1)
+   * @param rule 舍入规则 (standard, standard_down, always_up, always_down)
+   * @returns 舍入后的金额（保留两位小数的字符串）
    */
-  async getUnsyncedOrdersAsync() {
+  async roundAmountAsync(originalAmount, interval, rule) {
     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);
-      });
+      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);
-      return [];
+      console.error("[PaymentModule] 金额舍入失败:", error);
+      throw new Error(`金额舍入失败: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   /**
-   * 清理已完成且已同步的订单
-   * 注意：只清理完全支付的订单，部分支付的订单保留以便继续支付
+   * 标准舍入处理（处理中点情况）
+   * 
+   * @param value 要舍入的值
+   * @param midpointUp 中点是否向上舍入
+   * @returns 舍入后的值
    */
-  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_info.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_info.order_id
-      });
-      return false;
+  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;
     }
   }
 };