@pisell/pisellos 0.0.230 → 0.0.232

package/lib/solution/Checkout/index.js

@@ -45,13 +45,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     if (!this.request) {
       throw new Error("Checkout 解决方案需要 request 插件支持");
     }
+    this.order = new import_Order.OrderModule();
+    this.payment = new import_Payment.PaymentModule();
     this.store = {
-      order: new import_Order.OrderModule(),
-      payment: new import_Payment.PaymentModule(),
       status: import_types.CheckoutStatus.Initializing,
       step: import_types.CheckoutStep.OrderConfirmation,
       cartItems: [],
-      paymentMethods: []
+      paymentMethods: [],
+      stateAmount: "0.00",
+      cartSummary: void 0,
+      isOrderSynced: false,
+      currentCustomer: void 0
     };
     await this.initializeSubModules(core, options);
     await this.preloadPaymentMethods();
@@ -66,11 +70,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async initializeSubModules(core, options) {
     var _a, _b;
-    core.registerModule(this.store.order, {
+    core.registerModule(this.order, {
       store: ((_a = options.store) == null ? void 0 : _a.order) || {},
       otherParams: { ...this.otherParams, parentModule: this.name }
     });
-    core.registerModule(this.store.payment, {
+    core.registerModule(this.payment, {
       store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
       otherParams: { ...this.otherParams, parentModule: this.name }
     });
@@ -115,6 +119,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
+  getProductListByOrder() {
+    var _a;
+    if (!this.store.currentOrder) {
+      return [];
+    }
+    const productList = (_a = this.store.currentOrder.order_info) == null ? void 0 : _a.original_order_data.bookings.map((item) => ({
+      product_id: item.product.product_id,
+      product_variant_id: item.product.product_variant_id,
+      quantity: item.product.num,
+      selling_price: item.product.price - (item.product.discount_amount || 0)
+    }));
+    return productList;
+  }
   /**
    * 创建本地订单 (前端模拟下单流程)
    * 
@@ -123,6 +140,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
    */
   async createLocalOrderAsync(params) {
+    var _a, _b, _c, _d, _e;
     try {
       await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
       const validation = await this.validateLocalOrderData(params.orderData);
@@ -134,8 +152,24 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       }
       const localOrderId = this.generateLocalOrderId();
       const amountInfo = this.extractAmountFromCartSummary(params.cartSummary);
+      params.orderData.platform = "pos";
+      params.orderData.created_at = this.formatDateTime(/* @__PURE__ */ new Date());
+      params.orderData.surcharge_fee = (_b = (_a = params.totalInfo) == null ? void 0 : _a.total) == null ? void 0 : _b.paySurchargeFee;
+      params.orderData.shop_discount = (_d = (_c = params.totalInfo) == null ? void 0 : _c.total) == null ? void 0 : _d.shopDiscount;
       this.store.localOrderData = params.orderData;
-      const paymentOrder = await this.store.payment.createPaymentOrderAsync({
+      this.store.cartSummary = params.cartSummary;
+      const customerInfo = {
+        customer_id: params.orderData.customer_id,
+        customer_name: params.orderData.customer_name
+      };
+      if (customerInfo.customer_id || customerInfo.customer_name) {
+        this.store.currentCustomer = customerInfo;
+        console.log("[Checkout] 保存客户信息:", customerInfo);
+      } else {
+        this.store.currentCustomer = void 0;
+        console.log("[Checkout] 未提供客户信息");
+      }
+      const paymentOrder = await this.payment.createPaymentOrderAsync({
         order_id: localOrderId,
         total_amount: amountInfo.totalAmount,
         is_deposit: params.orderData.is_deposit || 0,
@@ -144,7 +178,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           original_order_data: params.orderData,
           cart_summary: params.cartSummary,
           created_at: (/* @__PURE__ */ new Date()).toISOString(),
-          platform: params.orderData.platform.toLowerCase(),
+          platform: params.orderData.platform,
           type: params.orderData.type,
           schedule_date: params.orderData.schedule_date,
           shop_note: params.orderData.shop_note,
@@ -152,6 +186,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
       });
       this.store.currentOrder = paymentOrder;
+      const walletBusinessData = {
+        customer_id: ((_e = this.store.currentCustomer) == null ? void 0 : _e.customer_id) ? Number(this.store.currentCustomer.customer_id) : void 0,
+        amountInfo: {
+          totalAmount: amountInfo.totalAmount,
+          subTotal: amountInfo.subTotal
+        },
+        products: this.getProductListByOrder()
+      };
+      const walletData = await this.payment.wallet.initializeWalletDataFromBusinessAsync(walletBusinessData);
+      console.log(walletData.walletRecommendList, "walletRecommendList");
+      console.log(walletData.userIdentificationCodes, "userIdentificationCodes");
       await this.setStatus(import_types.CheckoutStatus.OrderCreated);
       await this.setStep(import_types.CheckoutStep.PaymentMethod);
       if (params.autoPayment) {
@@ -161,12 +206,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         order: paymentOrder,
         timestamp: Date.now()
       });
+      await this.updateStateAmountToRemaining();
       console.log("[Checkout] 本地订单创建成功:", {
         localOrderId,
         uuid: paymentOrder.uuid,
         totalAmount: amountInfo.totalAmount,
         subTotal: amountInfo.subTotal,
-        taxAmount: amountInfo.taxAmount
+        taxAmount: amountInfo.taxAmount,
+        stateAmount: this.store.stateAmount
       });
       return paymentOrder;
     } catch (error) {
@@ -184,7 +231,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
    */
   async placeOrderAsync(params = {}) {
-    var _a, _b;
+    var _a;
     try {
       if (!this.store.localOrderData) {
         throw (0, import_utils.createCheckoutError)(
@@ -203,14 +250,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const orderData = {
         cartItems: this.store.cartItems,
         type: this.store.localOrderData.type,
-        platform: (_a = this.store.localOrderData.platform) == null ? void 0 : _a.toLowerCase()
+        platform: this.store.localOrderData.platform
       };
-      const orderResponse = await this.store.order.submitOrder({
+      const orderResponse = await this.order.submitOrder({
         url: params.url,
         // 可选的自定义 URL
         query: orderData
       });
-      const realOrderId = ((_b = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _b.order_id) || (orderResponse == null ? void 0 : orderResponse.order_id);
+      const realOrderId = ((_a = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _a.order_id) || (orderResponse == null ? void 0 : orderResponse.order_id);
       if (!realOrderId) {
         throw (0, import_utils.createCheckoutError)(
           import_types.CheckoutErrorType.OrderCreationFailed,
@@ -233,6 +280,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         order: this.store.currentOrder,
         timestamp: Date.now()
       });
+      this.store.isOrderSynced = true;
       console.log("[Checkout] 手动下单流程完成");
       return {
         success: true,
@@ -260,7 +308,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     var _a;
     try {
       await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
-      const checkResult = this.store.order.checkBeforeSubmitOrder({
+      const checkResult = this.order.checkBeforeSubmitOrder({
         cartItems: params.cartItems,
         type: "account"
         // 默认使用 account 类型
@@ -271,14 +319,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "购物车数据验证失败，请检查商品信息"
         );
       }
-      const orderResponse = await this.store.order.submitOrder({
+      const orderResponse = await this.order.submitOrder({
         query: {
           cartItems: params.cartItems,
           type: params.type || "appointment_booking",
           platform: params.platform || "pc"
         }
       });
-      const paymentOrder = await this.store.payment.createPaymentOrderAsync({
+      const paymentOrder = await this.payment.createPaymentOrderAsync({
         order_id: ((_a = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _a.order_id) || `order_${Date.now()}`,
         total_amount: this.calculateTotalAmount(params.cartItems),
         order_info: orderResponse == null ? void 0 : orderResponse.data
@@ -290,6 +338,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         order: paymentOrder,
         timestamp: Date.now()
       });
+      this.store.isOrderSynced = true;
+      await this.updateStateAmountToRemaining();
       console.log("[Checkout] 订单创建成功:", paymentOrder.id);
       return paymentOrder;
     } catch (error) {
@@ -330,11 +380,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         amount: String(params.amount),
         id: paymentMethod.id
       };
-      await this.store.payment.pushPaymentAsync(
+      await this.payment.addPaymentItemAsync(
         this.store.currentOrder.uuid,
         paymentItem
       );
-      const result = await this.store.payment.submitPayAsync(
+      const result = await this.payment.submitPayAsync(
         this.store.currentOrder.uuid
       );
       await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
@@ -345,6 +395,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       if (result.status === "success") {
         await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+        await this.updateStateAmountToRemaining();
         await this.handlePaymentSuccess({
           orderUuid: this.store.currentOrder.uuid,
           timestamp: Date.now()
@@ -371,7 +422,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "未找到当前订单"
         );
       }
-      const order = await this.store.payment.getPaymentOrderByUuidAsync(
+      const order = await this.payment.getPaymentOrderByUuidAsync(
         this.store.currentOrder.uuid
       );
       if (!order || order.payment_status !== import_types2.PaymentStatus.Finished) {
@@ -380,6 +431,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "订单支付未完成，无法完成结账"
         );
       }
+      this.payment.wallet.clearAllCache();
       await this.setStatus(import_types.CheckoutStatus.Completed);
       await this.setStep(import_types.CheckoutStep.Complete);
       await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCompleted, {
@@ -402,9 +454,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async cancelCheckoutAsync() {
     try {
       if (this.store.currentOrder) {
-        await this.store.payment.deleteOrderAsync(this.store.currentOrder.uuid);
+        await this.payment.deletePaymentOrderAsync(this.store.currentOrder.uuid);
         this.store.currentOrder = void 0;
       }
+      this.store.localOrderData = void 0;
+      this.store.cartSummary = void 0;
+      this.payment.wallet.clearAllCache();
+      this.store.cartItems = [];
+      this.store.stateAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
       await this.setStatus(import_types.CheckoutStatus.Cancelled);
       await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCancelled, {
         timestamp: Date.now()
@@ -431,16 +490,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 获取结账摘要
    */
   async getCheckoutSummaryAsync() {
-    var _a, _b, _c;
+    var _a, _b;
     const totalAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0.00";
     const paidAmount = this.calculatePaidAmount();
-    const remainingAmount = ((_b = this.store.currentOrder) == null ? void 0 : _b.expect_amount) || totalAmount;
+    const remainingAmount = this.calculateRemainingAmount();
     return {
       order: this.store.currentOrder,
       totalAmount,
       paidAmount,
       remainingAmount,
-      paymentStatus: ((_c = this.store.currentOrder) == null ? void 0 : _c.payment_status) || import_types2.PaymentStatus.Processing,
+      paymentStatus: ((_b = this.store.currentOrder) == null ? void 0 : _b.payment_status) || import_types2.PaymentStatus.Processing,
       availablePaymentMethods: this.store.paymentMethods
     };
   }
@@ -464,13 +523,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     await this.preloadPaymentMethods();
     return this.store.paymentMethods;
   }
+  /**
+   * 获取订单原始数据
+   */
+  getOrderOriginalData() {
+    var _a;
+    return (_a = this.store.currentOrder) == null ? void 0 : _a.order_info;
+  }
   /**
    * 获取当前订单基础信息
    * 
    * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
    */
   getCurrentOrderInfo() {
-    var _a;
     try {
       const { currentOrder, status, step, cartItems, localOrderData } = this.store;
       if (!currentOrder) {
@@ -480,7 +545,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const orderInfo = currentOrder.order_info || {};
       const createdAt = orderInfo.created_at || (/* @__PURE__ */ new Date()).toISOString();
       const orderType = (localOrderData == null ? void 0 : localOrderData.type) || orderInfo.type || "virtual";
-      const platform = ((_a = localOrderData == null ? void 0 : localOrderData.platform) == null ? void 0 : _a.toLowerCase()) || orderInfo.platform || "pc";
+      const platform = (localOrderData == null ? void 0 : localOrderData.platform) || orderInfo.platform || "pc";
       const result = {
         uuid: currentOrder.uuid,
         orderId: currentOrder.order_id,
@@ -510,6 +575,43 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return null;
     }
   }
+  /**
+   * 获取当前订单的支付项
+   * 
+   * 返回当前订单的所有支付项，包括活跃和已撤销的支付项
+   */
+  async getCurrentOrderPaymentItemsAsync() {
+    try {
+      const { currentOrder } = this.store;
+      if (!currentOrder) {
+        console.log("[Checkout] 当前没有活跃订单，无法获取支付项");
+        return [];
+      }
+      console.log("[Checkout] 获取当前订单支付项:", {
+        orderUuid: currentOrder.uuid,
+        orderId: currentOrder.order_id
+      });
+      const paymentItems = await this.payment.getPaymentItemsAsync(currentOrder.uuid);
+      console.log("[Checkout] 成功获取支付项:", {
+        orderUuid: currentOrder.uuid,
+        paymentItemCount: paymentItems.length,
+        activeItems: paymentItems.filter((item) => item.status !== "voided").length,
+        voidedItems: paymentItems.filter((item) => item.status === "voided").length,
+        totalPaidAmount: paymentItems.filter((item) => item.status !== "voided").reduce((sum, item) => sum + parseFloat(item.amount || "0"), 0).toFixed(2),
+        paymentMethods: paymentItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount,
+          status: item.status,
+          voucher_id: item.voucher_id
+        }))
+      });
+      return paymentItems;
+    } catch (error) {
+      console.error("[Checkout] 获取当前订单支付项失败:", error);
+      return [];
+    }
+  }
   /**
    * 验证结账前置条件
    */
@@ -543,11 +645,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
               });
             }
             break;
-          case import_types.CheckoutErrorType.PaymentFailed:
-            if (this.store.currentOrder) {
-              await this.store.payment.runPaymentSyncQueue();
-            }
-            break;
           default:
             console.warn("[Checkout] 无法重试此类型的错误:", this.store.lastError.type);
         }
@@ -572,13 +669,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 获取订单模块
    */
   getOrderModule() {
-    return this.store.order;
+    return this.order;
   }
   /**
    * 获取支付模块
    */
   getPaymentModule() {
-    return this.store.payment;
+    return this.payment;
   }
   /**
    * 替换本地订单ID为真实订单ID
@@ -594,7 +691,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         console.warn("[Checkout] 没有当前订单，无法替换订单ID");
         return null;
       }
-      const updatedOrder = await this.store.payment.replaceOrderIdByUuidAsync(
+      const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
         this.store.currentOrder.uuid,
         newOrderId
       );
@@ -608,6 +705,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           uuid: updatedOrder.uuid,
           newOrderId: updatedOrder.id
         });
+        this.store.isOrderSynced = true;
+        await this.updateStateAmountToRemaining();
       }
       return updatedOrder;
     } catch (error) {
@@ -616,6 +715,765 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return null;
     }
   }
+  /**
+   * 设置自定义支付金额
+   * 
+   * 允许UI自定义本次支付的金额，通常用于部分支付或调整支付金额场景
+   * 
+   * @param amount 自定义支付金额，必须是有效的数字字符串
+   */
+  async setStateAmountAsync(amount) {
+    try {
+      const numAmount = parseFloat(amount);
+      if (isNaN(numAmount) || numAmount < 0) {
+        throw new Error(`无效的支付金额: ${amount}`);
+      }
+      const oldAmount = this.store.stateAmount;
+      const formattedAmount = numAmount.toFixed(2);
+      if (oldAmount === formattedAmount) {
+        return;
+      }
+      this.store.stateAmount = formattedAmount;
+      await this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
+        oldAmount,
+        newAmount: formattedAmount,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 自定义支付金额已更新:", {
+        oldAmount,
+        newAmount: formattedAmount
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "设置支付金额失败";
+      console.error("[Checkout] 设置自定义支付金额失败:", errorMessage);
+      await this.handleError(
+        new Error(errorMessage),
+        import_types.CheckoutErrorType.ValidationFailed
+      );
+      throw error;
+    }
+  }
+  /**
+   * 获取当前自定义支付金额
+   * 
+   * @returns 当前设置的自定义支付金额
+   */
+  getStateAmount() {
+    return this.store.stateAmount;
+  }
+  /**
+   * 刷新 stateAmount 为当前剩余未支付金额
+   * 
+   * UI 可以调用此方法来主动刷新支付金额状态
+   */
+  async refreshStateAmountAsync() {
+    await this.updateStateAmountToRemaining();
+  }
+  /**
+   * 获取购物车小计数据
+   * 
+   * 返回当前结账流程中的购物车小计项数据，包含各种费用明细
+   * 
+   * @returns 购物车小计数据数组，如果没有则返回 null
+   */
+  getCartSummary() {
+    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
+      console.warn("[Checkout] 没有可用的购物车小计数据");
+      return null;
+    }
+    console.log("[Checkout] 获取购物车小计数据:", {
+      itemCount: this.store.cartSummary.length,
+      items: this.store.cartSummary.map((item) => ({ key: item.key, value: item.value, label: item.label }))
+    });
+    return [...this.store.cartSummary];
+  }
+  /**
+   * 获取提取的金额详细信息
+   * 
+   * 从当前的购物车小计数据中提取结构化的金额信息
+   * 
+   * @returns 提取的金额信息对象，如果没有小计数据则返回 null
+   */
+  getExtractedAmountInfo() {
+    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
+      console.warn("[Checkout] 没有可用的购物车小计数据，无法提取金额信息");
+      return null;
+    }
+    const extractedInfo = this.extractAmountFromCartSummary(this.store.cartSummary);
+    console.log("[Checkout] 获取提取的金额信息:", extractedInfo);
+    return extractedInfo;
+  }
+  /**
+   * 获取支付方式列表
+   * 
+   * 直接调用 Payment 模块的 getPayMethodListAsync 方法
+   * 
+   * @returns 支付方式列表
+   */
+  async getPaymentMethodsAsync() {
+    return await this.payment.getPayMethodListAsync();
+  }
+  /**
+   * 为当前订单添加支付项
+   * 
+   * 向当前活跃订单添加一个支付项，支付项包含支付方式信息和金额
+   * 
+   * @param paymentItem 支付项数据
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async addPaymentItemAsync(paymentItem) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法添加支付项"
+        );
+      }
+      console.log("[Checkout] 为当前订单添加支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentItem: {
+          code: paymentItem.code,
+          name: paymentItem.name,
+          type: paymentItem.type,
+          amount: paymentItem.amount,
+          service_charge: paymentItem.service_charge
+        }
+      });
+      await this.payment.addPaymentItemAsync(
+        this.store.currentOrder.uuid,
+        paymentItem
+      );
+      console.log("[Checkout] 支付项添加成功");
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+      console.log("[Checkout] 准备同步订单数据:", {
+        当前订单ID: currentOrderId,
+        是否为真实ID: isCurrentOrderReal
+      });
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      if (updatedOrder) {
+        if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
+          console.warn("[Checkout] 检测到订单ID回退，保护真实订单ID:", {
+            当前真实ID: currentOrderId,
+            获取到的虚拟ID: updatedOrder.order_id
+          });
+          updatedOrder.order_id = currentOrderId;
+        }
+        this.store.currentOrder = updatedOrder;
+        console.log("[Checkout] 订单数据已同步:", {
+          支付项数量: updatedOrder.payment.length,
+          最终订单ID: updatedOrder.order_id,
+          是否为虚拟ID: this.isVirtualOrderId(updatedOrder.order_id)
+        });
+      }
+      const needsOrderSync = this.shouldSyncOrderForPayment(paymentItem.code, paymentItem.type);
+      console.log("[Checkout] 支付项同步检查:", {
+        paymentCode: paymentItem.code,
+        paymentType: paymentItem.type,
+        paymentAmount: paymentItem.amount,
+        expectedCashCode: import_types2.PaymentMethodType.Cash,
+        needsOrderSync,
+        isOrderSynced: this.store.isOrderSynced
+      });
+      if (needsOrderSync) {
+        console.log("[Checkout] 检测到非现金/自定义支付，开始同步订单到后端...", {
+          同步前订单ID: this.store.currentOrder.order_id,
+          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
+          订单同步状态: this.store.isOrderSynced,
+          订单UUID: this.store.currentOrder.uuid
+        });
+        await this.syncOrderToBackend();
+        console.log("[Checkout] addPaymentItemAsync 中的同步完成:", {
+          同步后订单ID: this.store.currentOrder.order_id,
+          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
+          订单同步状态: this.store.isOrderSynced
+        });
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: paymentItem.code,
+        amount: String(paymentItem.amount),
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      console.error("[Checkout] 添加支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 删除当前订单的支付项
+   * 
+   * 从当前活跃订单中删除指定的支付项，支付项将被标记为已撤销状态
+   * 
+   * @param paymentUuid 要删除的支付项UUID
+   * @throws 当前没有活跃订单时抛出错误
+   * @throws 支付项不存在时抛出错误
+   */
+  async deletePaymentItemAsync(paymentUuid) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法删除支付项"
+        );
+      }
+      console.log("[Checkout] 开始删除支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentUuid
+      });
+      const paymentItem = this.store.currentOrder.payment.find((p) => p.uuid === paymentUuid);
+      if (!paymentItem) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `支付项不存在: ${paymentUuid}`
+        );
+      }
+      console.log("[Checkout] 找到要删除的支付项:", {
+        uuid: paymentItem.uuid,
+        code: paymentItem.code,
+        amount: paymentItem.amount,
+        status: paymentItem.status
+      });
+      await this.payment.deletePaymentAsync(
+        this.store.currentOrder.uuid,
+        paymentUuid
+      );
+      console.log("[Checkout] Payment模块删除完成");
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      if (updatedOrder) {
+        if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
+          console.warn("[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:", {
+            当前真实ID: currentOrderId,
+            获取到的虚拟ID: updatedOrder.order_id
+          });
+          updatedOrder.order_id = currentOrderId;
+        }
+        this.store.currentOrder = updatedOrder;
+        console.log("[Checkout] 订单数据已同步，当前支付项数量:", updatedOrder.payment.length);
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: paymentItem.code,
+        amount: `-${paymentItem.amount}`,
+        // 负数表示删除
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 支付项删除成功");
+    } catch (error) {
+      console.error("[Checkout] 删除支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 批量更新当前订单的代金券支付项（覆盖更新）
+   * 
+   * 删除所有现有的代金券支付项，然后添加新的代金券支付项。
+   * 这是一个覆盖式更新操作，确保代金券支付项的一致性。
+   * 
+   * @param voucherPaymentItems 新的代金券支付项列表，每个都必须包含 voucher_id
+   * @throws 当前没有活跃订单时抛出错误
+   * @throws 支付项缺少 voucher_id 时抛出错误
+   */
+  async updateVoucherPaymentItemsAsync(voucherPaymentItems) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法更新代金券支付项"
+        );
+      }
+      console.log("[Checkout] 开始批量更新代金券支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        newVoucherCount: voucherPaymentItems.length,
+        voucherPaymentItems
+      });
+      for (const item of voucherPaymentItems) {
+        if (!item.voucher_id) {
+          throw (0, import_utils.createCheckoutError)(
+            import_types.CheckoutErrorType.ValidationFailed,
+            `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`
+          );
+        }
+      }
+      await this.payment.updateVoucherPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        voucherPaymentItems
+      );
+      console.log("[Checkout] Payment模块批量更新完成");
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      if (updatedOrder) {
+        if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
+          console.warn("[Checkout] updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:", {
+            当前真实ID: currentOrderId,
+            获取到的虚拟ID: updatedOrder.order_id
+          });
+          updatedOrder.order_id = currentOrderId;
+        }
+        this.store.currentOrder = updatedOrder;
+        console.log("[Checkout] 订单数据已同步，当前支付项数量:", updatedOrder.payment.length);
+        const voucherItems = updatedOrder.payment.filter(
+          (payment) => payment.voucher_id && payment.status !== "voided"
+        );
+        console.log("[Checkout] 更新后的代金券支付项:", {
+          voucherCount: voucherItems.length,
+          items: voucherItems.map((item) => ({
+            uuid: item.uuid,
+            code: item.code,
+            amount: item.amount,
+            voucher_id: item.voucher_id
+          }))
+        });
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: "VOUCHER_BATCH",
+        amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 代金券支付项批量更新成功");
+    } catch (error) {
+      console.error("[Checkout] 批量更新代金券支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 修改当前订单的定金状态
+   * 
+   * 更新当前订单的 is_deposit 字段，用于标识订单是否为定金订单
+   * 
+   * @param isDeposit 定金状态 (1: 定金订单, 0: 全款订单)
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async updateOrderDepositStatusAsync(isDeposit) {
+    try {
+      if (isDeposit !== 0 && isDeposit !== 1) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "isDeposit 参数只能是 0（全款订单）或 1（定金订单）"
+        );
+      }
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法修改定金状态"
+        );
+      }
+      const newDepositValue = isDeposit;
+      const oldDepositValue = this.store.currentOrder.is_deposit;
+      if (oldDepositValue === newDepositValue) {
+        console.log("[Checkout] 定金状态无变化，跳过更新");
+        return;
+      }
+      console.log("[Checkout] 更新订单定金状态:", {
+        orderUuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id,
+        oldIsDeposit: oldDepositValue,
+        newIsDeposit: newDepositValue
+      });
+      const updateParams = {
+        is_deposit: newDepositValue
+      };
+      if (isDeposit === 0 && this.store.currentOrder.deposit_amount !== "0.00") {
+        updateParams.deposit_amount = "0.00";
+        console.log("[Checkout] 订单从定金改为全款，清空定金金额");
+      }
+      await this.payment.updateOrderAsync(this.store.currentOrder.uuid, updateParams);
+      this.store.currentOrder = {
+        ...this.store.currentOrder,
+        ...updateParams
+      };
+      if (this.store.localOrderData) {
+        this.store.localOrderData.is_deposit = newDepositValue;
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: this.store.currentOrder,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 订单定金状态更新成功:", {
+        isDeposit: newDepositValue,
+        depositAmount: this.store.currentOrder.deposit_amount
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新订单定金状态失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 更新当前订单的客户信息
+   * 
+   * 更新当前订单关联的客户信息，用于标识订单的所属客户
+   * 
+   * @param customer 客户信息 (customer_id 和/或 customer_name)
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async updateOrderCustomerAsync(customer) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法更新客户信息"
+        );
+      }
+      console.log("[Checkout] 更新订单客户信息:", {
+        orderUuid: this.store.currentOrder.uuid,
+        oldCustomer: this.store.currentCustomer,
+        newCustomer: customer
+      });
+      this.store.currentCustomer = {
+        customer_id: customer.customer_id,
+        customer_name: customer.customer_name
+      };
+      if (this.store.localOrderData) {
+        this.store.localOrderData.customer_id = customer.customer_id;
+        this.store.localOrderData.customer_name = customer.customer_name;
+      }
+      console.log("[Checkout] 订单客户信息更新成功:", this.store.currentCustomer);
+    } catch (error) {
+      console.error("[Checkout] 更新订单客户信息失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 获取当前订单的客户信息
+   * 
+   * @returns 当前客户信息，如果没有则返回 null
+   */
+  getCurrentCustomer() {
+    return this.store.currentCustomer || null;
+  }
+  /**
+   * 检查订单是否需要手动同步
+   * 
+   * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
+   */
+  needsManualSync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder || this.store.isOrderSynced) {
+        return false;
+      }
+      const remainingAmount = this.calculateRemainingAmount();
+      const remainingValue = parseFloat(remainingAmount);
+      if (remainingValue > 0) {
+        return false;
+      }
+      const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+        (item) => item.status !== "voided" && item.voucher_id
+      );
+      console.log("[Checkout] needsManualSync 检查结果:", {
+        orderUuid: this.store.currentOrder.uuid,
+        isOrderSynced: this.store.isOrderSynced,
+        remainingAmount,
+        hasPayments: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) > 0,
+        allPaymentsHaveVoucherId,
+        needsManualSync: allPaymentsHaveVoucherId
+      });
+      return allPaymentsHaveVoucherId;
+    } catch (error) {
+      console.error("[Checkout] needsManualSync 检查失败:", error);
+      return false;
+    }
+  }
+  /**
+   * 手动同步订单到后端
+   * 
+   * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
+   */
+  async manualSyncOrderAsync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder) {
+        return {
+          success: false,
+          message: "当前没有活跃订单，无法同步"
+        };
+      }
+      const orderUuid = this.store.currentOrder.uuid;
+      const oldOrderId = this.store.currentOrder.order_id;
+      if (this.store.isOrderSynced) {
+        console.log("[Checkout] 订单已同步过，将执行更新操作");
+      }
+      console.log("[Checkout] 开始手动同步订单到后端:", {
+        orderUuid,
+        orderId: oldOrderId,
+        totalAmount: this.store.currentOrder.total_amount,
+        remainingAmount: this.calculateRemainingAmount()
+      });
+      const realOrderId = await this.syncOrderToBackendWithReturn(true);
+      console.log("[Checkout] 手动同步订单完成:", {
+        orderUuid,
+        oldOrderId,
+        realOrderId,
+        isOrderSynced: this.store.isOrderSynced
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      const finalIsVirtual = this.isVirtualOrderId(finalOrderId);
+      console.log("[Checkout] manualSyncOrderAsync 最终状态验证:", {
+        返回的订单ID: realOrderId,
+        存储的订单ID: finalOrderId,
+        存储的ID是否虚拟: finalIsVirtual,
+        是否一致: realOrderId === finalOrderId,
+        同步状态: this.store.isOrderSynced
+      });
+      if (finalIsVirtual) {
+        console.error("[Checkout] 严重警告：手动同步完成后订单ID仍为虚拟ID！");
+      }
+      if (realOrderId !== finalOrderId) {
+        console.error("[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！");
+      }
+      return {
+        success: true,
+        message: "订单同步成功",
+        orderId: realOrderId,
+        // 直接返回从后端获取的真实订单ID
+        orderUuid
+      };
+    } catch (error) {
+      console.error("[Checkout] 手动同步订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "同步失败";
+      return {
+        success: false,
+        message: `订单同步失败: ${errorMessage}`,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      };
+    }
+  }
+  /**
+   * 获取当前订单备注
+   * 
+   * @returns 当前订单的备注内容，如果没有则返回空字符串
+   */
+  getOrderNote() {
+    if (!this.store.localOrderData) {
+      console.log("[Checkout] 没有本地订单数据，无法获取备注");
+      return "";
+    }
+    return this.store.localOrderData.shop_note || "";
+  }
+  /**
+   * 获取当前订单ID
+   * 
+   * @returns 当前订单的ID，如果没有订单则返回null
+   */
+  getCurrentOrderId() {
+    if (!this.store.currentOrder) {
+      return null;
+    }
+    return this.store.currentOrder.order_id;
+  }
+  /**
+   * 保存订单并稍后支付
+   * 
+   * 将当前订单保存到后端，但排除代金券类支付项(voucher_id)，
+   * 适用于用户想要保存订单但稍后完成支付的场景
+   */
+  async saveForLaterPaymentAsync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder) {
+        return {
+          success: false,
+          message: "当前没有活跃订单，无法保存"
+        };
+      }
+      const orderUuid = this.store.currentOrder.uuid;
+      const currentOrderId = this.store.currentOrder.order_id;
+      console.log("[Checkout] 开始保存订单并稍后支付:", {
+        orderUuid,
+        orderId: currentOrderId,
+        totalAmount: this.store.currentOrder.total_amount
+      });
+      const allPaymentItems = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+      const filteredPaymentItems = allPaymentItems.filter(
+        (payment) => !payment.voucher_id || payment.voucher_id.trim() === ""
+      );
+      const voucherItems = allPaymentItems.filter(
+        (payment) => payment.voucher_id && payment.voucher_id.trim() !== ""
+      );
+      console.log("[Checkout] 支付项过滤结果:", {
+        总支付项: allPaymentItems.length,
+        过滤后支付项: filteredPaymentItems.length,
+        被过滤的代金券项: voucherItems.length,
+        代金券详情: voucherItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount,
+          voucherId: item.voucher_id
+        })),
+        保留的支付项: filteredPaymentItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount
+        }))
+      });
+      const realOrderId = await this.syncOrderToBackendWithReturn(false, filteredPaymentItems);
+      console.log("[Checkout] 保存订单完成:", {
+        orderUuid,
+        oldOrderId: currentOrderId,
+        realOrderId,
+        isOrderSynced: this.store.isOrderSynced,
+        filteredPaymentsCount: filteredPaymentItems.length
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      console.log("[Checkout] saveForLaterPaymentAsync 最终状态验证:", {
+        返回的订单ID: realOrderId,
+        存储的订单ID: finalOrderId,
+        是否一致: realOrderId === finalOrderId,
+        同步状态: this.store.isOrderSynced
+      });
+      return {
+        success: true,
+        message: "订单保存成功，可稍后继续支付",
+        orderId: realOrderId,
+        orderUuid
+      };
+    } catch (error) {
+      console.error("[Checkout] 保存订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "保存失败";
+      return {
+        success: false,
+        message: `订单保存失败: ${errorMessage}`,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      };
+    }
+  }
+  /**
+   * 获取当前商店折扣金额
+   * 
+   * @returns 当前的商店折扣金额，如果没有则返回0
+   */
+  getShopDiscount() {
+    var _a;
+    if (((_a = this.store.localOrderData) == null ? void 0 : _a.shop_discount) !== void 0) {
+      return this.store.localOrderData.shop_discount;
+    }
+    if (this.store.cartSummary) {
+      const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+      if (shopDiscountItem) {
+        return shopDiscountItem.value;
+      }
+    }
+    return 0;
+  }
+  /**
+   * 更新订单商店折扣
+   * 
+   * 同时更新cartSummary和localOrderData中的shop_discount值
+   * 
+   * @param discountAmount 商店折扣金额
+   */
+  async updateShopDiscountAsync(discountAmount) {
+    var _a, _b;
+    try {
+      const oldDiscount = this.getShopDiscount();
+      console.log("[Checkout] 更新商店折扣:", {
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        oldDiscount,
+        newDiscount: discountAmount
+      });
+      if (this.store.cartSummary) {
+        const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+        if (shopDiscountItem) {
+          shopDiscountItem.value = discountAmount;
+          console.log("[Checkout] cartSummary 中的商店折扣已更新");
+        } else {
+          this.store.cartSummary.push({
+            key: "shop_discount",
+            value: discountAmount,
+            hidden: true,
+            label: "Shop Discount"
+          });
+          console.log("[Checkout] cartSummary 中已添加新的商店折扣项");
+        }
+      }
+      if (this.store.localOrderData) {
+        this.store.localOrderData.shop_discount = discountAmount;
+        console.log("[Checkout] localOrderData 中的商店折扣已更新");
+      } else {
+        console.warn("[Checkout] localOrderData 不存在，无法更新商店折扣");
+      }
+      if (this.store.currentOrder && this.store.cartSummary) {
+        const updatedAmountInfo = this.extractAmountFromCartSummary(this.store.cartSummary);
+        console.log("[Checkout] 重新计算订单金额:", updatedAmountInfo);
+        this.store.currentOrder.total_amount = updatedAmountInfo.totalAmount;
+        this.store.currentOrder.expect_amount = updatedAmountInfo.totalAmount;
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnShopDiscountChanged, {
+        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+        oldDiscount,
+        newDiscount: discountAmount,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 商店折扣更新成功:", {
+        oldDiscount,
+        newDiscount: discountAmount
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新商店折扣失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 更新订单备注
+   * 
+   * @param note 订单备注内容
+   */
+  async updateOrderNoteAsync(note) {
+    var _a, _b;
+    try {
+      if (!this.store.localOrderData) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有本地订单数据，无法更新备注"
+        );
+      }
+      console.log("[Checkout] 更新订单备注:", {
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        oldNote: this.store.localOrderData.shop_note,
+        newNote: note
+      });
+      const oldNote = this.store.localOrderData.shop_note;
+      this.store.localOrderData.shop_note = note;
+      if (this.store.currentOrder) {
+        try {
+          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+          if (orderInPayment && orderInPayment.note !== void 0) {
+            console.log("[Checkout] 同步备注到Payment模块的订单数据中");
+          }
+        } catch (syncError) {
+          console.warn("[Checkout] 同步备注到Payment模块失败，但本地更新成功:", syncError);
+        }
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+        oldNote,
+        newNote: note,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 订单备注更新成功:", {
+        oldNote,
+        newNote: note
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新订单备注失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
   /**
    * 设置状态
    */
@@ -660,6 +1518,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async handlePaymentSuccess(data) {
     var _a;
     await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+    await this.updateStateAmountToRemaining();
     await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentSuccess, {
       orderUuid: data.orderUuid,
       paymentMethodCode: "",
@@ -731,6 +1590,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     const random = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
     return `local_order_${timestamp}_${random}`;
   }
+  /**
+   * 格式化日期时间为 YYYY-MM-DD hh:mm:ss 格式
+   * 
+   * @param date 要格式化的日期对象
+   * @returns 格式化后的日期时间字符串
+   */
+  formatDateTime(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  }
   /**
    * 从购物车小计数据中提取金额信息
    */
@@ -790,7 +1664,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async preloadPaymentMethods() {
     try {
       console.log("[Checkout] 预加载支付方式...");
-      const methods = await this.store.payment.getPayMethodListAsync();
+      const methods = await this.payment.getPayMethodListAsync();
       this.store.paymentMethods = methods;
       console.log(`[Checkout] 预加载完成，共 ${methods.length} 种支付方式`);
     } catch (error) {
@@ -813,12 +1687,381 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 计算已支付金额
    */
   calculatePaidAmount() {
-    if (!this.store.currentOrder)
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculatePaidAmount: 没有当前订单");
       return "0.00";
-    const paidAmount = this.store.currentOrder.payment.reduce((sum, payment) => {
-      return sum + parseFloat(payment.amount);
+    }
+    const payments = this.store.currentOrder.payment || [];
+    console.log("[Checkout] calculatePaidAmount: 支付项详情:", {
+      paymentCount: payments.length,
+      payments: payments.map((p) => ({
+        uuid: p.uuid,
+        amount: p.amount,
+        code: p.code,
+        status: p.status
+      }))
+    });
+    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
+      const amount = parseFloat(payment.amount || "0");
+      console.log(`[Checkout] 计算支付项: ${payment.code} = ${amount}`);
+      return sum + amount;
     }, 0);
-    return paidAmount.toFixed(2);
+    const result = paidAmount.toFixed(2);
+    console.log("[Checkout] calculatePaidAmount: 计算结果 =", result);
+    return result;
+  }
+  /**
+   * 计算剩余未支付金额
+   */
+  calculateRemainingAmount() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculateRemainingAmount: 没有当前订单");
+      return "0.00";
+    }
+    const totalAmount = parseFloat(this.store.currentOrder.total_amount || "0");
+    const paidAmount = parseFloat(this.calculatePaidAmount());
+    const remainingAmount = totalAmount - paidAmount;
+    const result = Math.max(0, remainingAmount).toFixed(2);
+    console.log("[Checkout] calculateRemainingAmount: 计算详情:", {
+      orderUuid: this.store.currentOrder.uuid,
+      totalAmount: totalAmount.toFixed(2),
+      paidAmount: paidAmount.toFixed(2),
+      calculatedRemaining: remainingAmount.toFixed(2),
+      finalResult: result
+    });
+    return result;
+  }
+  /**
+   * 更新 stateAmount 为当前剩余未支付金额
+   */
+  async updateStateAmountToRemaining() {
+    var _a;
+    try {
+      const remainingAmount = this.calculateRemainingAmount();
+      const currentStateAmount = this.store.stateAmount;
+      console.log("[Checkout] updateStateAmountToRemaining: 状态检查:", {
+        calculatedRemainingAmount: remainingAmount,
+        currentStateAmount,
+        needsUpdate: remainingAmount !== currentStateAmount,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      });
+      if (remainingAmount !== currentStateAmount) {
+        this.store.stateAmount = remainingAmount;
+        await this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
+          oldAmount: currentStateAmount,
+          newAmount: remainingAmount,
+          timestamp: Date.now()
+        });
+        console.log("[Checkout] stateAmount 已自动更新为剩余金额:", {
+          oldAmount: currentStateAmount,
+          newAmount: remainingAmount
+        });
+      } else {
+        console.log("[Checkout] stateAmount 无需更新，当前值已是最新:", {
+          stateAmount: currentStateAmount,
+          remainingAmount
+        });
+      }
+      await this.checkOrderPaymentCompletion();
+    } catch (error) {
+      console.error("[Checkout] 更新 stateAmount 为剩余金额失败:", error);
+    }
+  }
+  /**
+   * 检查订单支付是否完成
+   * 
+   * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+   */
+  async checkOrderPaymentCompletion() {
+    var _a, _b;
+    try {
+      if (!this.store.currentOrder) {
+        return;
+      }
+      const remainingAmount = this.calculateRemainingAmount();
+      const remainingValue = parseFloat(remainingAmount);
+      if (remainingValue <= 0) {
+        const totalAmount = this.store.currentOrder.total_amount;
+        const paidAmount = this.calculatePaidAmount();
+        console.log("[Checkout] 检测到订单支付完成:", {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          isOrderSynced: this.store.isOrderSynced
+        });
+        const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+          (item) => item.status !== "voided" && item.voucher_id
+        );
+        console.log("[Checkout] 支付项voucher_id检查:", {
+          paymentCount: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) || 0,
+          allHaveVoucherId: allPaymentsHaveVoucherId,
+          paymentItems: (_b = this.store.currentOrder.payment) == null ? void 0 : _b.map((p) => ({
+            uuid: p.uuid,
+            code: p.code,
+            amount: p.amount,
+            voucher_id: p.voucher_id,
+            status: p.status
+          }))
+        });
+        if (!this.store.isOrderSynced) {
+          if (allPaymentsHaveVoucherId) {
+            console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
+          } else {
+            console.log("[Checkout] 支付完成但订单未同步，开始同步订单到后端...");
+            await this.syncOrderToBackend();
+          }
+        }
+        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderPaymentCompleted, {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error("[Checkout] 检查订单支付完成状态失败:", error);
+    }
+  }
+  /**
+   * 判断支付方式是否需要同步订单到后端
+   * 
+   * 现金支付(CASHMANUAL)和自定义支付不需要同步，其他支付方式需要同步
+   * 
+   * @param paymentCode 支付方式代码
+   * @param paymentType 支付方式类型 
+   * @returns 是否需要同步订单
+   */
+  shouldSyncOrderForPayment(paymentCode, paymentType) {
+    const codeUpper = (paymentCode == null ? void 0 : paymentCode.toUpperCase()) || "";
+    const typeUpper = (paymentType == null ? void 0 : paymentType.toUpperCase()) || "";
+    const cashIdentifiers = ["CASHMANUAL", "CASH", "MANUAL"];
+    if (cashIdentifiers.some((id) => codeUpper.includes(id) || typeUpper.includes(id))) {
+      return false;
+    }
+    if (paymentCode === import_types2.PaymentMethodType.Cash || paymentType === import_types2.PaymentMethodType.Cash) {
+      return false;
+    }
+    if (codeUpper.includes("CUSTOM") || typeUpper.includes("CUSTOM")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 同步订单到后端
+   * 
+   * 调用后端 /order/checkout 接口创建真实订单
+   */
+  /**
+   * 判断订单ID是否为本地生成的虚拟ID
+   * 
+   * @param orderId 订单ID
+   * @returns true 表示是虚拟ID，false 表示是真实的后端ID
+   */
+  isVirtualOrderId(orderId) {
+    return orderId.startsWith("local_order_");
+  }
+  /**
+   * 同步订单到后端并返回真实订单ID
+   * 
+   * @param isManual 是否为手动同步，默认为 false
+   * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
+   * @returns 后端返回的真实订单ID
+   */
+  async syncOrderToBackendWithReturn(isManual = false, customPaymentItems) {
+    var _a, _b, _c, _d;
+    if (!this.store.localOrderData || !this.store.currentOrder) {
+      throw new Error("缺少必要的订单数据，无法同步到后端");
+    }
+    const syncType = isManual ? "手动" : "自动";
+    const currentOrderId = this.store.currentOrder.order_id;
+    const hasRealOrderId = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+    let isUpdateOperation = false;
+    let reason = "";
+    if (this.store.isOrderSynced) {
+      isUpdateOperation = true;
+      reason = "订单已同步过";
+    } else if (hasRealOrderId) {
+      isUpdateOperation = true;
+      reason = "有真实订单ID";
+    } else {
+      isUpdateOperation = false;
+      reason = "既未同步也无真实ID";
+    }
+    const operation = isUpdateOperation ? "更新" : "创建";
+    console.log("[Checkout] 操作类型判断详情:", {
+      currentOrderId,
+      hasRealOrderId,
+      isOrderSynced: this.store.isOrderSynced,
+      isManual,
+      reason,
+      finalDecision: operation
+    });
+    console.log(`[Checkout] 开始${syncType}${operation}订单到后端...`, {
+      currentOrderId,
+      isVirtualId: this.isVirtualOrderId(currentOrderId || ""),
+      operation,
+      orderUuid: this.store.currentOrder.uuid,
+      isOrderSynced: this.store.isOrderSynced
+    });
+    const paymentItems = customPaymentItems || await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+    console.log("[Checkout] 获取到支付项:", {
+      count: paymentItems.length,
+      isCustomFiltered: !!customPaymentItems,
+      methods: paymentItems.map((p) => p.code),
+      totalAmount: paymentItems.reduce((sum, p) => sum + parseFloat(p.amount), 0).toFixed(2),
+      paymentDetails: paymentItems.map((p) => {
+        var _a2;
+        return {
+          uuid: p.uuid,
+          code: p.code,
+          amount: p.amount,
+          uniquePaymentNumber: (_a2 = p.metadata) == null ? void 0 : _a2.unique_payment_number,
+          voucherId: p.voucher_id
+        };
+      })
+    });
+    const orderParams = {
+      ...this.store.localOrderData,
+      type: this.store.localOrderData.type,
+      platform: this.store.localOrderData.platform,
+      payments: paymentItems,
+      // 添加支付项
+      customer_id: (_a = this.store.currentCustomer) == null ? void 0 : _a.customer_id,
+      // 添加客户ID
+      is_price_include_tax: this.otherParams.is_price_include_tax,
+      // core 有
+      tax_title: this.otherParams.tax_title,
+      // core 没有
+      tax_rate: this.otherParams.tax_rate,
+      // core 有
+      tax_country_code: this.otherParams.tax_country_code,
+      // core 没有
+      currency_code: this.otherParams.currency_code,
+      currency_symbol: this.otherParams.currency_symbol,
+      currency_format: this.otherParams.currency_format,
+      is_deposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit) || 0,
+      deposit_amount: ((_c = this.store.currentOrder) == null ? void 0 : _c.deposit_amount) || "0.00",
+      // surcharge_fee: this.otherParams.surcharge_fee,
+      // surcharges: ,
+      note: this.store.localOrderData.shop_note
+      // deposit_amount: 
+    };
+    if (isUpdateOperation) {
+      if (this.isVirtualOrderId(currentOrderId)) {
+        console.error("[Checkout] 数据不一致警告：更新操作但订单ID仍为虚拟ID!", {
+          currentOrderId,
+          isOrderSynced: this.store.isOrderSynced,
+          reason,
+          orderUuid: this.store.currentOrder.uuid
+        });
+        console.log("[Checkout] 尝试数据修复：暂时不包含order_id，让后端处理");
+        console.log("[Checkout] 注意：这次调用将作为创建操作处理，但后续会修复数据一致性");
+      } else {
+        orderParams.order_id = currentOrderId;
+        console.log(`[Checkout] 更新订单操作，包含订单ID: ${currentOrderId}`);
+      }
+    } else {
+      console.log("[Checkout] 创建新订单操作");
+    }
+    const checkoutResponse = await this.order.createOrderByCheckout(orderParams);
+    console.log("[Checkout] 后端返回的响应数据:", {
+      status: checkoutResponse == null ? void 0 : checkoutResponse.status,
+      code: checkoutResponse == null ? void 0 : checkoutResponse.code,
+      message: checkoutResponse == null ? void 0 : checkoutResponse.message,
+      data: checkoutResponse == null ? void 0 : checkoutResponse.data
+    });
+    let realOrderId;
+    if (isUpdateOperation) {
+      realOrderId = currentOrderId;
+      console.log(`[Checkout] 订单更新成功，订单ID: ${realOrderId}`);
+    } else {
+      let extractedOrderId = (_d = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _d.order_id;
+      if (!extractedOrderId) {
+        extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
+      }
+      if (extractedOrderId !== void 0 && extractedOrderId !== null) {
+        extractedOrderId = String(extractedOrderId);
+      }
+      if (!extractedOrderId) {
+        throw new Error("后端返回的订单信息中未包含订单ID");
+      }
+      realOrderId = extractedOrderId;
+      console.log("[Checkout] 订单创建成功，真实订单ID:", realOrderId);
+      console.log("[Checkout] 准备替换订单ID:", {
+        orderUuid: this.store.currentOrder.uuid,
+        oldOrderId: this.store.currentOrder.order_id,
+        newOrderId: realOrderId
+      });
+      try {
+        const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
+          this.store.currentOrder.uuid,
+          realOrderId
+        );
+        console.log("[Checkout] Payment模块替换订单ID结果:", {
+          wasSuccessful: !!updatedOrder,
+          returnedOrderId: updatedOrder == null ? void 0 : updatedOrder.order_id,
+          expectedOrderId: realOrderId
+        });
+        if (updatedOrder) {
+          console.log("[Checkout] Payment模块返回的更新后订单:", {
+            uuid: updatedOrder.uuid,
+            orderId: updatedOrder.order_id,
+            totalAmount: updatedOrder.total_amount
+          });
+          this.store.currentOrder = updatedOrder;
+          console.log("[Checkout] 订单ID替换成功，当前订单ID:", this.store.currentOrder.order_id);
+        } else {
+          console.error("[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换");
+          const beforeManualUpdate = this.store.currentOrder.order_id;
+          this.store.currentOrder.order_id = realOrderId;
+          console.log("[Checkout] 手动设置订单ID:", {
+            替换前: beforeManualUpdate,
+            替换后: this.store.currentOrder.order_id,
+            目标ID: realOrderId
+          });
+        }
+      } catch (error) {
+        console.error("[Checkout] 调用Payment模块替换订单ID时发生错误:", error);
+        this.store.currentOrder.order_id = realOrderId;
+        console.log("[Checkout] 错误恢复：手动设置订单ID:", realOrderId);
+      }
+    }
+    this.store.isOrderSynced = true;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSynced, {
+      orderUuid: this.store.currentOrder.uuid,
+      realOrderId,
+      virtualOrderId: this.store.currentOrder.order_id,
+      timestamp: Date.now(),
+      isManual,
+      response: checkoutResponse
+    });
+    const finalOrderId = this.store.currentOrder.order_id;
+    const finalIsVirtual = this.isVirtualOrderId(finalOrderId || "");
+    console.log(`[Checkout] ${syncType}${operation}订单到后端完成`, {
+      返回的订单ID: realOrderId,
+      当前存储的订单ID: finalOrderId,
+      是否还是虚拟ID: finalIsVirtual,
+      是否同步: this.store.isOrderSynced
+    });
+    if (finalIsVirtual && !isUpdateOperation) {
+      console.warn("[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题");
+    }
+    return realOrderId;
+  }
+  async syncOrderToBackend() {
+    try {
+      await this.syncOrderToBackendWithReturn(false);
+    } catch (error) {
+      console.error("[Checkout] 同步订单到后端失败:", error);
+      await this.handleError(
+        new Error(`订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
+    }
   }
   /**
    * 获取状态消息
@@ -848,11 +2091,90 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         return "";
     }
   }
+  async setOtherParams(params, { cover = false } = {}) {
+    if (cover) {
+      this.otherParams = params;
+    } else {
+      this.otherParams = { ...this.otherParams, ...params };
+    }
+  }
+  /**
+   * 通过订单ID编辑订单备注
+   * 
+   * 用于修改已同步到后端的订单备注，通常在支付成功后的弹窗中使用
+   * 
+   * @param orderId 后端订单ID
+   * @param note 新的订单备注
+   * @returns 修改结果
+   */
+  async editOrderNoteByOrderIdAsync(orderId, note) {
+    try {
+      console.log("[Checkout] 开始编辑订单备注:", {
+        orderId,
+        note,
+        noteLength: note.length
+      });
+      if (!orderId) {
+        return {
+          success: false,
+          message: "订单ID不能为空",
+          orderId
+        };
+      }
+      const response = await this.request.put(`/shop/order/order/${orderId}/note`, {
+        note
+      });
+      console.log("[Checkout] 订单备注编辑响应:", {
+        orderId,
+        status: response.status,
+        message: response.message,
+        response
+      });
+      if (response.status === true || response.status === 200) {
+        console.log(`[Checkout] 订单 ${orderId} 备注修改成功`);
+        if (this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId))) {
+          console.log("[Checkout] 更新本地订单备注状态");
+          const previousNote = this.getOrderNote();
+          if (this.store.localOrderData) {
+            this.store.localOrderData.shop_note = note;
+          }
+          await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+            orderUuid: this.store.currentOrder.uuid,
+            oldNote: previousNote,
+            newNote: note,
+            timestamp: Date.now()
+          });
+        }
+        return {
+          success: true,
+          message: response.message || "订单备注修改成功",
+          orderId
+        };
+      } else {
+        const errorMessage = response.message || "订单备注修改失败";
+        console.error(`[Checkout] 订单 ${orderId} 备注修改失败:`, errorMessage);
+        return {
+          success: false,
+          message: errorMessage,
+          orderId
+        };
+      }
+    } catch (error) {
+      console.error("[Checkout] 编辑订单备注失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      return {
+        success: false,
+        message: `编辑订单备注失败: ${errorMessage}`,
+        orderId
+      };
+    }
+  }
   async destroy() {
     var _a, _b, _c, _d;
+    this.payment.wallet.clearAllCache();
     this.core.effects.offByModuleDestroy(this.name);
-    await ((_b = (_a = this.store.order) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a));
-    await ((_d = (_c = this.store.payment) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c));
+    await ((_b = (_a = this.order) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a));
+    await ((_d = (_c = this.payment) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c));
     this.core.unregisterModule(this);
     console.log("[Checkout] 已销毁");
   }