@pisell/pisellos 1.0.65 → 1.0.67

package/lib/solution/Checkout/index.js

@@ -65,8 +65,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     this.order = new import_Order.OrderModule();
     this.payment = new import_Payment.PaymentModule();
     this.store = {
-      status: import_types.CheckoutStatus.Initializing,
-      step: import_types.CheckoutStep.OrderConfirmation,
       cartItems: [],
       paymentMethods: [],
       stateAmount: "0.00",
@@ -78,7 +76,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     await this.initializeSubModules(core, options);
     await this.preloadPaymentMethods();
     await this.cleanupExpiredOrdersAsync();
-    this.setStatus(import_types.CheckoutStatus.Ready);
     console.log("[Checkout] 初始化完成");
     await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutInitialized, {
       timestamp: Date.now()
@@ -92,7 +89,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     if (this.logger) {
       this.logger.addLog({
         type: "info",
-        title: `[CheckoutModule] ${title}`,
+        title: `[CheckoutModule]  ${this.getCurrentOrderId()} ${title}`,
         metadata: metadata || {}
       });
     }
@@ -128,11 +125,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     var _a, _b;
     core.registerModule(this.order, {
       store: ((_a = options.store) == null ? void 0 : _a.order) || {},
-      otherParams: { ...this.otherParams, parentModule: this.name }
+      otherParams: { ...this.otherParams, fatherModule: this.name }
     });
     core.registerModule(this.payment, {
       store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
-      otherParams: { ...this.otherParams, parentModule: this.name }
+      otherParams: { ...this.otherParams, fatherModule: this.name }
     });
     this.setupPaymentEventListeners();
   }
@@ -181,7 +178,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       platform: params.platform
     });
     try {
-      this.setStatus(import_types.CheckoutStatus.Initializing);
       const validation = this.validateCheckoutParams(params);
       if (!validation.valid) {
         throw (0, import_utils.createCheckoutError)(
@@ -190,8 +186,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         );
       }
       this.store.cartItems = params.cartItems;
-      this.setStatus(import_types.CheckoutStatus.Ready);
-      this.setStep(import_types.CheckoutStep.OrderConfirmation);
       console.log("[Checkout] 结账流程初始化完成");
     } catch (error) {
       await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
@@ -213,21 +207,29 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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) - getDiscountListAmount(item.product.discount_list)
+        selling_price: item.product.calculated_selling_price
+      })
+    )) || [];
+    const relationProducts = ((_e = (_d = (_c = this.store.currentOrder.order_info) == null ? void 0 : _c.original_order_data) == null ? void 0 : _d.relation_products) == null ? void 0 : _e.map(
+      (item) => ({
+        product_id: item.product_id,
+        product_variant_id: item.product_variant_id,
+        quantity: item.num,
+        selling_price: item.source_product_price
       })
     )) || [];
-    const relationProducts = ((_e = (_d = (_c = this.store.currentOrder.order_info) == null ? void 0 : _c.original_order_data) == null ? void 0 : _d.relation_products) == null ? void 0 : _e.map((item) => ({
-      product_id: item.product_id,
-      product_variant_id: item.product_variant_id,
-      quantity: item.num,
-      selling_price: item.source_product_price
-    }))) || [];
     return [...productList, ...relationProducts];
   }
   async initWalletData(params) {
     var _a, _b, _c, _d;
+    this.logInfo("initWalletData called", {
+      params
+    });
     const amountInfo = (_b = (_a = this.store.currentOrder) == null ? void 0 : _a.order_info) == null ? void 0 : _b.amount_breakdown;
     if (!amountInfo) {
+      this.logInfo("initWalletData amountInfo not found", {
+        params
+      });
       return;
     }
     const walletBusinessData = {
@@ -239,9 +241,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       products: this.getProductListByOrder(),
       ...params
     };
+    this.logInfo("开始拉取:initializeWalletDataFromBusinessAsync", {
+      walletBusinessData
+    });
     await this.payment.wallet.initializeWalletDataFromBusinessAsync(
       walletBusinessData
     );
+    this.logInfo("调用结束:initializeWalletDataFromBusinessAsync", {
+      walletBusinessData
+    });
+    if (!this.store.currentOrder) {
+      return;
+    }
+    this.logInfo("initWalletData currentOrder found", {
+      currentOrder: this.store.currentOrder
+    });
     await this.core.effects.emit(import_types.CheckoutHooks.OnWalletDataInitialized, {
       orderUuid: (_d = this.store.currentOrder) == null ? void 0 : _d.uuid,
       customerId: walletBusinessData.customer_id,
@@ -273,9 +287,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
     try {
-      console.time("createLocalOrderAsync");
       await this.resetStoreStateAsync();
-      this.setStatus(import_types.CheckoutStatus.CreatingOrder);
       const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
       if (!validation.valid) {
         throw (0, import_utils.createCheckoutError)(
@@ -320,20 +332,15 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           amount_breakdown: amountInfo
         }
       });
-      console.timeEnd("createLocalOrderAsync");
       this.store.currentOrder = paymentOrder;
-      this.initWalletData();
-      this.setStatus(import_types.CheckoutStatus.OrderCreated);
-      this.setStep(import_types.CheckoutStep.PaymentMethod);
       if (params.autoPayment) {
-        this.setStep(import_types.CheckoutStep.PaymentProcessing);
       }
       this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
         order: paymentOrder,
         timestamp: Date.now()
       });
       await this.updateStateAmountToRemaining();
-      console.log("[Checkout] 本地订单创建成功:", {
+      this.logInfo("本地订单创建成功:", {
         localOrderId,
         uuid: paymentOrder.uuid,
         totalAmount: amountInfo.totalAmount,
@@ -341,12 +348,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         taxAmount: amountInfo.taxAmount,
         stateAmount: this.store.stateAmount
       });
+      this.initWalletData();
       return paymentOrder;
     } catch (error) {
       await this.handleError(
         error,
         import_types.CheckoutErrorType.OrderCreationFailed
       );
+      this.logError("本地订单创建失败:", error);
       this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
         error: this.store.lastError,
         timestamp: Date.now()
@@ -354,206 +363,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 手动下单 (根据虚拟订单生成实际订单)
-   *
-   * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
-   */
-  async placeOrderAsync(params = {}) {
-    var _a, _b;
-    this.logInfo("placeOrderAsync called", {
-      url: params.url,
-      autoReplaceOrderId: params.autoReplaceOrderId,
-      hasLocalOrderData: !!this.store.localOrderData,
-      hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
-      isOrderSynced: this.store.isOrderSynced
-    });
-    try {
-      if (!this.store.localOrderData) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "没有找到本地订单数据，请先调用 createLocalOrderAsync 创建虚拟订单"
-        );
-      }
-      if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "没有找到当前订单，请先创建虚拟订单"
-        );
-      }
-      console.log("[Checkout] 开始手动下单流程...");
-      this.setStatus(import_types.CheckoutStatus.CreatingOrder);
-      const orderData = {
-        cartItems: this.store.cartItems,
-        type: this.store.localOrderData.type,
-        platform: this.store.localOrderData.platform
-      };
-      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);
-      if (!realOrderId) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.OrderCreationFailed,
-          "订单创建成功但未返回订单ID"
-        );
-      }
-      console.log("[Checkout] 真实订单创建成功:", realOrderId);
-      if (params.autoReplaceOrderId !== false) {
-        console.log("[Checkout] 自动替换虚拟订单ID为真实订单ID...");
-        const updatedOrder = await this.replaceLocalOrderIdAsync(realOrderId);
-        if (updatedOrder) {
-          console.log("[Checkout] 订单ID替换成功:", {
-            oldId: this.store.currentOrder.order_id,
-            newId: realOrderId
-          });
-        }
-      }
-      this.setStatus(import_types.CheckoutStatus.OrderCreated);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
-        order: this.store.currentOrder,
-        timestamp: Date.now()
-      });
-      this.store.isOrderSynced = true;
-      console.log("[Checkout] 手动下单流程完成");
-      return {
-        success: true,
-        orderId: realOrderId
-      };
-    } catch (error) {
-      let errorMessage = "下单失败";
-      if (error && typeof error === "object" && "message" in error) {
-        errorMessage = error.message;
-      } else if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      console.error("[Checkout] 手动下单失败:", errorMessage);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.OrderCreationFailed
-      );
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * 创建订单
-   */
-  async createOrderAsync(params) {
-    var _a;
-    try {
-      this.setStatus(import_types.CheckoutStatus.CreatingOrder);
-      const checkResult = this.order.checkBeforeSubmitOrder({
-        cartItems: params.cartItems,
-        type: "account"
-        // 默认使用 account 类型
-      });
-      if (!checkResult) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "购物车数据验证失败，请检查商品信息"
-        );
-      }
-      const orderResponse = await this.order.submitOrder({
-        query: {
-          cartItems: params.cartItems,
-          type: params.type || "appointment_booking",
-          platform: params.platform || "pc"
-        }
-      });
-      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: (0, import_utils.calculateTotalAmount)(params.cartItems),
-        order_info: orderResponse == null ? void 0 : orderResponse.data
-      });
-      this.store.currentOrder = paymentOrder;
-      this.setStatus(import_types.CheckoutStatus.OrderCreated);
-      this.setStep(import_types.CheckoutStep.PaymentMethod);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
-        order: paymentOrder,
-        timestamp: Date.now()
-      });
-      this.store.isOrderSynced = true;
-      await this.updateStateAmountToRemaining();
-      console.log("[Checkout] 订单创建成功:", paymentOrder.id);
-      return paymentOrder;
-    } catch (error) {
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.OrderCreationFailed
-      );
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
-        error: this.store.lastError,
-        timestamp: Date.now()
-      });
-      throw error;
-    }
-  }
-  /**
-   * 处理支付
-   */
-  async processPaymentAsync(params) {
-    try {
-      if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，请先创建订单"
-        );
-      }
-      this.setStatus(import_types.CheckoutStatus.ProcessingPayment);
-      this.setStep(import_types.CheckoutStep.PaymentProcessing);
-      const paymentMethod = this.store.paymentMethods.find(
-        (method) => method.code === params.paymentMethodCode
-      );
-      if (!paymentMethod) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          `未找到支付方式: ${params.paymentMethodCode}`
-        );
-      }
-      const paymentItem = {
-        code: paymentMethod.code,
-        name: paymentMethod.name,
-        type: paymentMethod.type,
-        amount: String(params.amount),
-        id: paymentMethod.id
-      };
-      await this.payment.addPaymentItemAsync(
-        this.store.currentOrder.uuid,
-        paymentItem
-      );
-      const result = await this.payment.submitPayAsync(
-        this.store.currentOrder.uuid
-      );
-      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
-        orderUuid: this.store.currentOrder.uuid,
-        paymentMethodCode: params.paymentMethodCode,
-        amount: String(params.amount),
-        timestamp: Date.now()
-      });
-      if (result.status === "success") {
-        this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
-        await this.updateStateAmountToRemaining();
-        await this.handlePaymentSuccess({
-          orderUuid: this.store.currentOrder.uuid,
-          timestamp: Date.now()
-        });
-      } else {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.PaymentFailed,
-          "支付处理失败，请重试"
-        );
-      }
-    } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
-      throw error;
-    }
-  }
   /**
    * 完成结账
    */
@@ -575,8 +384,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         );
       }
       this.payment.wallet.clearAllCache();
-      this.setStatus(import_types.CheckoutStatus.Completed);
-      this.setStep(import_types.CheckoutStep.Complete);
       await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCompleted, {
         orderId: order.id,
         timestamp: Date.now()
@@ -592,89 +399,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return { success: false };
     }
   }
-  /**
-   * 取消结账
-   */
-  async cancelCheckoutAsync() {
-    try {
-      if (this.store.currentOrder) {
-        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.balanceDueAmount = "0.00";
-      this.store.isOrderSynced = false;
-      this.store.currentCustomer = void 0;
-      this.setStatus(import_types.CheckoutStatus.Cancelled);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCancelled, {
-        timestamp: Date.now()
-      });
-      console.log("[Checkout] 结账流程已取消");
-    } catch (error) {
-      console.error("[Checkout] 取消结账失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
-    }
-  }
-  /**
-   * 获取结账状态
-   */
-  getCheckoutStatus() {
-    return {
-      status: this.store.status,
-      step: this.store.step,
-      progress: (0, import_utils.calculateProgress)(this.store.status, this.store.step),
-      message: this.getStatusMessage(),
-      error: this.store.lastError
-    };
-  }
-  /**
-   * 获取结账摘要
-   */
-  async getCheckoutSummaryAsync() {
-    var _a, _b;
-    const totalAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0.00";
-    const paidAmount = await this.calculatePaidAmountAsync();
-    const remainingAmount = await this.calculateRemainingAmountAsync();
-    return {
-      order: this.store.currentOrder,
-      totalAmount,
-      paidAmount,
-      remainingAmount,
-      paymentStatus: ((_b = this.store.currentOrder) == null ? void 0 : _b.payment_status) || import_types2.PaymentStatus.Processing,
-      availablePaymentMethods: this.store.paymentMethods
-    };
-  }
-  /**
-   * 获取可用支付方式
-   */
-  async getAvailablePaymentMethodsAsync() {
-    return await this.getPaymentMethodsAsync();
-  }
-  /**
-   * 刷新支付方式缓存
-   *
-   * 强制重新从服务器获取支付方式列表，更新本地缓存
-   */
-  async refreshPaymentMethodsAsync() {
-    console.log("[Checkout] 强制刷新支付方式缓存...");
-    try {
-      const methods = await this.payment.getPayMethodListAsync();
-      this.store.paymentMethods = methods;
-      console.log(
-        `[Checkout] 强制刷新完成，获取到 ${methods.length} 种支付方式`
-      );
-      return methods;
-    } catch (error) {
-      console.error("[Checkout] 强制刷新支付方式失败:", error);
-      return this.store.paymentMethods;
-    }
-  }
   /**
    * 获取订单原始数据
    */
@@ -689,7 +413,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   getCurrentOrderInfo() {
     try {
-      const { currentOrder, status, step, cartItems, localOrderData } = this.store;
+      const { currentOrder, cartItems, localOrderData } = this.store;
       if (!currentOrder) {
         console.log("[Checkout] 当前没有活跃订单");
         return null;
@@ -701,8 +425,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const result = {
         uuid: currentOrder.uuid,
         orderId: currentOrder.order_id,
-        status,
-        step,
         totalAmount: currentOrder.total_amount,
         remainingAmount: currentOrder.expect_amount,
         paymentStatus: currentOrder.payment_status,
@@ -714,13 +436,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         itemCount: cartItems.length,
         hasLocalOrderData: Boolean(localOrderData)
       };
-      console.log("[Checkout] 获取当前订单基础信息:", {
-        uuid: result.uuid,
-        orderId: result.orderId,
-        status: result.status,
-        totalAmount: result.totalAmount,
-        remainingAmount: result.remainingAmount
-      });
       return result;
     } catch (error) {
       console.error("[Checkout] 获取当前订单基础信息失败:", error);
@@ -739,89 +454,15 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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 [];
     }
   }
-  /**
-   * 验证结账前置条件
-   */
-  async validateCheckoutAsync() {
-    const errors = [];
-    if (!this.store.cartItems || this.store.cartItems.length === 0) {
-      errors.push("购物车为空");
-    }
-    if (this.store.paymentMethods.length === 0) {
-      errors.push("无可用支付方式");
-    }
-    if (this.store.status === import_types.CheckoutStatus.Error) {
-      errors.push("结账流程存在错误");
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * 重试失败的操作
-   */
-  async retryFailedOperationAsync() {
-    try {
-      if (this.store.status === import_types.CheckoutStatus.Error && this.store.lastError) {
-        switch (this.store.lastError.type) {
-          case import_types.CheckoutErrorType.OrderCreationFailed:
-            if (this.store.cartItems.length > 0) {
-              await this.createOrderAsync({
-                cartItems: this.store.cartItems
-              });
-            }
-            break;
-          default:
-            console.warn(
-              "[Checkout] 无法重试此类型的错误:",
-              this.store.lastError.type
-            );
-        }
-      }
-    } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
-    }
-  }
-  /**
-   * 设置当前步骤
-   */
-  setCurrentStep(step) {
-    const oldStep = this.store.step;
-    this.store.step = step;
-    this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
-      oldStep,
-      newStep: step,
-      timestamp: Date.now()
-    });
-  }
   /**
    * 获取订单模块
    */
@@ -890,7 +531,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       if (oldAmount === formattedAmount) {
         return;
       }
-      this.logger.info("[Checkout] 设置自定义支付金额:", {
+      this.logInfo("[Checkout] 设置自定义支付金额:", {
         oldAmount,
         newAmount: formattedAmount
       });
@@ -900,10 +541,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         newAmount: formattedAmount,
         timestamp: Date.now()
       });
-      console.log("[Checkout] 自定义支付金额已更新:", {
-        oldAmount,
-        newAmount: formattedAmount
-      });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "设置支付金额失败";
       console.error("[Checkout] 设置自定义支付金额失败:", errorMessage);
@@ -932,14 +569,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   getBalanceDueAmount() {
     return this.store.balanceDueAmount;
   }
-  /**
-   * 刷新 stateAmount 为当前剩余未支付金额
-   *
-   * UI 可以调用此方法来主动刷新支付金额状态
-   */
-  async refreshStateAmountAsync() {
-    await this.updateStateAmountToRemaining();
-  }
   /**
    * 获取购物车小计数据
    *
@@ -952,7 +581,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.warn("[Checkout] 没有可用的购物车小计数据");
       return null;
     }
-    console.log("[Checkout] 获取购物车小计数据:", {
+    this.logInfo("获取购物车小计数据:", {
       itemCount: this.store.cartSummary.length,
       items: this.store.cartSummary.map((item) => ({
         key: item.key,
@@ -962,24 +591,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     });
     return [...this.store.cartSummary];
   }
-  /**
-   * 获取提取的金额详细信息
-   *
-   * 从当前的购物车小计数据中提取结构化的金额信息
-   *
-   * @returns 提取的金额信息对象，如果没有小计数据则返回 null
-   */
-  getExtractedAmountInfo() {
-    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
-      console.warn("[Checkout] 没有可用的购物车小计数据，无法提取金额信息");
-      return null;
-    }
-    const extractedInfo = (0, import_utils.extractAmountFromCartSummary)(
-      this.store.cartSummary
-    );
-    console.log("[Checkout] 获取提取的金额信息:", extractedInfo);
-    return extractedInfo;
-  }
   /**
    * 获取支付方式列表
    *
@@ -990,21 +601,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async getPaymentMethodsAsync() {
     if (this.store.paymentMethods && this.store.paymentMethods.length > 0) {
-      console.log(
-        `[Checkout] 使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`
+      this.logInfo(
+        `使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`
       );
       return this.store.paymentMethods;
     }
-    console.log("[Checkout] store 中无缓存，从 Payment 模块获取支付方式...");
+    this.logInfo("store 中无缓存，从 Payment 模块获取支付方式...");
     try {
       const methods = await this.payment.getPayMethodListAsync();
       this.store.paymentMethods = methods;
-      console.log(
-        `[Checkout] 从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`
+      this.logInfo(
+        `从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`
       );
       return methods;
     } catch (error) {
-      console.error("[Checkout] 获取支付方式失败:", error);
+      this.logError("获取支付方式失败:", error);
       return [];
     }
   }
@@ -1017,19 +628,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @throws 当前没有活跃订单时抛出错误
    */
   async addPaymentItemAsync(paymentItem) {
-    var _a, _b, _c, _d, _e, _f;
-    this.logInfo("addPaymentItemAsync called", {
-      paymentCode: paymentItem.code,
-      paymentType: paymentItem.type,
-      amount: paymentItem.amount,
-      voucherId: paymentItem.voucher_id,
-      serviceCharge: paymentItem.service_charge,
-      roundingAmount: paymentItem.rounding_amount,
-      hasMetadata: !!paymentItem.metadata,
-      hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
-      isDepositOrder: (_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit
-    });
+    var _a, _b;
+    this.logInfo("addPaymentItemAsync called", paymentItem);
     try {
       if (!this.store.currentOrder) {
         throw (0, import_utils.createCheckoutError)(
@@ -1049,66 +649,53 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         order_payment_type: orderPaymentType,
         metadata
       };
-      console.log("[Checkout] 为当前订单添加支付项:", {
-        orderUuid: this.store.currentOrder.uuid,
-        paymentItem: {
-          code: paymentItemWithType.code,
-          name: paymentItemWithType.name,
-          type: paymentItemWithType.type,
-          amount: paymentItemWithType.amount,
-          service_charge: paymentItemWithType.service_charge,
-          rounding_amount: paymentItemWithType.rounding_amount,
-          voucher_id: paymentItemWithType.voucher_id,
-          order_payment_type: paymentItemWithType.order_payment_type,
-          metadata: paymentItemWithType.metadata
-        },
-        orderDepositStatus: this.store.currentOrder.is_deposit,
-        calculatedOrderPaymentType: orderPaymentType,
-        // 现金支付找零详情
-        isCashPayment: this.isCashPayment(paymentItem.code, paymentItem.type),
-        originalAmount: paymentItem.amount,
-        processedAmount: paymentItemWithType.amount,
-        actualPaidAmount: (_c = paymentItemWithType.metadata) == null ? void 0 : _c.actual_paid_amount,
-        changeGivenAmount: (_d = paymentItemWithType.metadata) == null ? void 0 : _d.change_given_amount
-      });
       await this.payment.addPaymentItemAsync(
         this.store.currentOrder.uuid,
         paymentItemWithType
       );
-      console.log("[Checkout] 支付项添加成功");
-      const isEftposPayment = ((_e = paymentItem.type) == null ? void 0 : _e.toLowerCase()) === "eftpos" || ((_f = paymentItem.code) == null ? void 0 : _f.toUpperCase().includes("EFTPOS"));
-      console.log("[Checkout] EFTPOS 支付检查:", {
-        paymentCode: paymentItem.code,
-        paymentType: paymentItem.type,
-        isEftposPayment,
-        currentOrderSynced: this.store.isOrderSynced
-      });
-      if (isEftposPayment) {
-        console.log("[Checkout] 检测到 EFTPOS 支付，立即同步订单到后端...");
-        try {
-          const syncResult = await this.syncOrderToBackendWithReturn(true);
-          console.log("[Checkout] EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
-            orderId: syncResult.orderId,
-            isOrderSynced: this.store.isOrderSynced,
-            backendResponse: syncResult.response
-          });
-        } catch (error) {
-          console.error("[Checkout] EFTPOS 支付后订单同步失败:", error);
-          await this.handleError(
-            new Error(`EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
-            import_types.CheckoutErrorType.OrderCreationFailed
-          );
+      this.logInfo("支付项添加成功");
+      await this.updateStateAmountToRemaining();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      if (Number(remainingAmount) > 0) {
+        this.logInfo("订单金额还有待付的，同步 EFTPOS 支付");
+        const isEftposPayment = ((_a = paymentItem.type) == null ? void 0 : _a.toLowerCase()) === "eftpos" || ((_b = paymentItem.code) == null ? void 0 : _b.toUpperCase().includes("EFTPOS"));
+        const isCashPayment2 = paymentItem.code === "CASHMANUAL";
+        const isCustomePayment = paymentItem.type === "custom";
+        this.logInfo("EFTPOS 支付检查:", {
+          paymentCode: paymentItem.code,
+          paymentType: paymentItem.type,
+          isEftposPayment,
+          currentOrderSynced: this.store.isOrderSynced
+        });
+        if (isEftposPayment || isCashPayment2 || isCustomePayment) {
+          this.logInfo("检测到 EFTPOS 支付，立即同步订单到后端...");
+          try {
+            const syncResult = await this.syncOrderToBackendWithReturn(true);
+            this.logInfo("EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
+              orderId: syncResult.orderId,
+              isOrderSynced: this.store.isOrderSynced,
+              backendResponse: syncResult.response
+            });
+          } catch (error) {
+            this.logError("EFTPOS 支付后订单同步失败:", error);
+            await this.handleError(
+              new Error(
+                `EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`
+              ),
+              import_types.CheckoutErrorType.OrderCreationFailed
+            );
+          }
         }
       }
-      await this.updateStateAmountToRemaining();
-      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentItemAdded, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
+        paymentMethodName: paymentItem.name,
         amount: String(paymentItem.amount),
         timestamp: Date.now()
       });
     } catch (error) {
-      console.error("[Checkout] 添加支付项失败:", error);
+      this.logError("添加支付项失败:", error);
       await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
@@ -1130,7 +717,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "当前没有活跃订单，无法删除支付项"
         );
       }
-      console.log("[Checkout] 开始删除支付项:", {
+      this.logWarning("开始删除支付项:", {
         orderUuid: this.store.currentOrder.uuid,
         paymentUuid
       });
@@ -1146,7 +733,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           `支付项不存在: ${paymentUuid}`
         );
       }
-      console.log("[Checkout] 找到要删除的支付项:", {
+      this.logInfo("找到要删除的支付项:", {
         uuid: paymentItem.uuid,
         code: paymentItem.code,
         amount: paymentItem.amount,
@@ -1156,7 +743,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.currentOrder.uuid,
         paymentUuid
       );
-      console.log("[Checkout] Payment模块删除完成");
+      this.logInfo("Payment支付项删除完成", paymentItem);
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
       const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
@@ -1164,7 +751,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       );
       if (updatedOrder) {
         if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
-          console.warn(
+          this.logWarning(
             "[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:",
             {
               currentRealId: currentOrderId,
@@ -1174,10 +761,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           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, {
@@ -1187,9 +770,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         // 负数表示删除
         timestamp: Date.now()
       });
-      console.log("[Checkout] 支付项删除成功");
     } catch (error) {
-      console.error("[Checkout] 删除支付项失败:", error);
+      this.logError("删除支付项失败:", error);
       await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
@@ -1212,9 +794,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "当前没有活跃订单，无法更新代金券支付项"
         );
       }
-      console.log("[Checkout] 开始批量更新代金券支付项:", {
-        orderUuid: this.store.currentOrder.uuid,
-        newVoucherCount: voucherPaymentItems.length,
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingValue = new import_decimal.default(remainingAmount);
+      const isOrderSynced = this.store.isOrderSynced;
+      if (remainingValue.lte(0) && isOrderSynced && voucherPaymentItems.length === 0) {
+        this.logInfo("订单已同步且支付完成，跳过清空代金券操作避免重复同步:", {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          remainingAmount,
+          isOrderSynced,
+          voucherPaymentItemsCount: voucherPaymentItems.length,
+          reason: "Order synced and payment completed, skip clear vouchers to avoid duplicate sync"
+        });
+        return;
+      }
+      this.logInfo("开始批量更新代金券支付项:", {
         voucherPaymentItems
       });
       const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
@@ -1236,16 +830,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           metadata
         };
       });
-      console.log("[Checkout] 代金券支付项订单支付类型设置:", {
-        orderDepositStatus: this.store.currentOrder.is_deposit,
-        calculatedOrderPaymentType: orderPaymentType,
-        itemsCount: voucherPaymentItemsWithType.length
-      });
       await this.payment.updateVoucherPaymentItemsAsync(
         this.store.currentOrder.uuid,
         voucherPaymentItemsWithType
       );
-      console.log("[Checkout] Payment模块批量更新完成");
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
       const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
@@ -1253,8 +841,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       );
       if (updatedOrder) {
         if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
-          console.warn(
-            "[Checkout] updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
+          this.logWarning(
+            "updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
             {
               currentRealId: currentOrderId,
               retrievedVirtualId: updatedOrder.order_id
@@ -1263,22 +851,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           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, {
@@ -1287,9 +859,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
         timestamp: Date.now()
       });
-      console.log("[Checkout] 代金券支付项批量更新成功");
+      this.logInfo("代金券支付项批量更新成功");
     } catch (error) {
-      console.error("[Checkout] 批量更新代金券支付项失败:", error);
+      this.logError("[Checkout] 批量更新代金券支付项失败:", error);
       await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
@@ -1322,18 +894,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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] 订单从定金改为全款，清空定金金额");
+        this.logInfo("订单从定金改为全款，清空定金金额");
       }
       await this.payment.updateOrderAsync(
         this.store.currentOrder.uuid,
@@ -1350,12 +916,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         order: this.store.currentOrder,
         timestamp: Date.now()
       });
-      console.log("[Checkout] 订单定金状态更新成功:", {
+      this.logInfo("订单定金状态更新成功:", {
         isDeposit: newDepositValue,
         depositAmount: this.store.currentOrder.deposit_amount
       });
     } catch (error) {
-      console.error("[Checkout] 更新订单定金状态失败:", error);
+      this.logError("更新订单定金状态失败:", error);
       await this.handleError(
         error,
         import_types.CheckoutErrorType.ValidationFailed
@@ -1364,40 +930,99 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 更新当前订单的客户信息
+   * 手动设置当前订单的定金金额
    *
-   * 更新当前订单关联的客户信息，用于标识订单的所属客户
+   * 允许手动设置订单的定金金额，通常用于用户自定义定金支付场景
    *
-   * @param customer 客户信息 (customer_id 和/或 customer_name)
+   * @param depositAmount 定金金额，必须是有效的数字字符串，且不能超过订单总额
    * @throws 当前没有活跃订单时抛出错误
+   * @throws 定金金额格式无效或超过订单总额时抛出错误
    */
-  async updateOrderCustomerAsync(customer) {
+  async setDepositAmountAsync(depositAmount) {
+    var _a, _b;
+    this.logInfo("setDepositAmountAsync called", {
+      depositAmount,
+      hasCurrentOrder: !!this.store.currentOrder,
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      currentTotalAmount: (_b = this.store.currentOrder) == null ? void 0 : _b.total_amount
+    });
     try {
+      const depositValue = new import_decimal.default(depositAmount);
+      if (depositValue.isNaN() || depositValue.lt(0)) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `无效的定金金额格式: ${depositAmount}`
+        );
+      }
       if (!this.store.currentOrder) {
         throw (0, import_utils.createCheckoutError)(
           import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法更新客户信息"
+          "未找到当前订单，无法设置定金金额"
         );
       }
-      console.log("[Checkout] 更新订单客户信息:", {
+      const totalAmount = new import_decimal.default(this.store.currentOrder.total_amount || "0");
+      if (depositValue.gt(totalAmount)) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `定金金额 ${depositAmount} 不能超过订单总额 ${totalAmount.toFixed(2)}`
+        );
+      }
+      const formattedDepositAmount = depositValue.toFixed(2);
+      const oldDepositAmount = this.store.currentOrder.deposit_amount || "0.00";
+      if (formattedDepositAmount === oldDepositAmount) {
+        this.logInfo("定金金额无变化，跳过更新:", {
+          currentAmount: oldDepositAmount,
+          newAmount: formattedDepositAmount
+        });
+        return;
+      }
+      this.logInfo("开始设置订单定金金额:", {
         orderUuid: this.store.currentOrder.uuid,
-        oldCustomer: this.store.currentCustomer,
-        newCustomer: customer
+        orderId: this.store.currentOrder.order_id,
+        oldDepositAmount,
+        newDepositAmount: formattedDepositAmount,
+        totalAmount: totalAmount.toFixed(2)
       });
-      this.store.currentCustomer = {
-        customer_id: customer.customer_id,
-        customer_name: customer.customer_name
+      const updateParams = {
+        deposit_amount: formattedDepositAmount
       };
-      if (this.store.localOrderData) {
-        this.store.localOrderData.customer_id = customer.customer_id;
-        this.store.localOrderData.customer_name = customer.customer_name;
+      if (depositValue.gt(0) && this.store.currentOrder.is_deposit !== 1) {
+        updateParams.is_deposit = 1;
+        this.logInfo("定金金额大于0，自动设置为定金订单");
+      } else if (depositValue.eq(0) && this.store.currentOrder.is_deposit === 1) {
+        updateParams.is_deposit = 0;
+        this.logInfo("定金金额为0，自动设置为全款订单");
       }
-      console.log(
-        "[Checkout] 订单客户信息更新成功:",
-        this.store.currentCustomer
+      await this.payment.updateOrderAsync(
+        this.store.currentOrder.uuid,
+        updateParams
       );
+      this.store.currentOrder = {
+        ...this.store.currentOrder,
+        ...updateParams
+      };
+      if (this.store.localOrderData) {
+        if ("deposit_amount" in this.store.localOrderData) {
+          this.store.localOrderData.deposit_amount = formattedDepositAmount;
+        }
+        if (updateParams.is_deposit !== void 0) {
+          this.store.localOrderData.is_deposit = updateParams.is_deposit;
+        }
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: this.store.currentOrder,
+        timestamp: Date.now()
+      });
+      this.logInfo("订单定金金额设置成功:", {
+        orderUuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id,
+        oldDepositAmount,
+        newDepositAmount: formattedDepositAmount,
+        isDeposit: this.store.currentOrder.is_deposit,
+        totalAmount: this.store.currentOrder.total_amount
+      });
     } catch (error) {
-      console.error("[Checkout] 更新订单客户信息失败:", error);
+      this.logError("设置订单定金金额失败:", error);
       await this.handleError(
         error,
         import_types.CheckoutErrorType.ValidationFailed
@@ -1405,58 +1030,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 获取当前订单的客户信息
-   *
-   * @returns 当前客户信息，如果没有则返回 null
-   */
-  getCurrentCustomer() {
-    return this.store.currentCustomer || null;
-  }
-  /**
-   * 检查订单是否需要手动同步（异步版本）
-   *
-   * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
-   * 从 Payment 模块获取最新的支付项数据
-   */
-  async needsManualSyncAsync() {
-    try {
-      if (!this.store.currentOrder || this.store.isOrderSynced) {
-        return false;
-      }
-      const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingValue = new import_decimal.default(remainingAmount);
-      if (remainingValue.gt(0)) {
-        return false;
-      }
-      const currentPayments = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        false
-        // 不包括已撤销的支付项
-      );
-      const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
-        (item) => item.status !== "voided" && item.voucher_id
-      );
-      console.log("[Checkout] needsManualSyncAsync 检查结果:", {
-        orderUuid: this.store.currentOrder.uuid,
-        isOrderSynced: this.store.isOrderSynced,
-        remainingAmount,
-        hasPayments: currentPayments.length > 0,
-        allPaymentsHaveVoucherId,
-        needsManualSync: allPaymentsHaveVoucherId,
-        paymentItems: currentPayments.map((p) => ({
-          code: p.code,
-          amount: p.amount,
-          status: p.status,
-          hasVoucherId: !!p.voucher_id
-        }))
-      });
-      return allPaymentsHaveVoucherId;
-    } catch (error) {
-      console.error("[Checkout] needsManualSyncAsync 检查失败:", error);
-      return false;
-    }
-  }
   /**
    * 手动同步订单到后端
    *
@@ -1482,16 +1055,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const orderUuid = this.store.currentOrder.uuid;
       const oldOrderId = this.store.currentOrder.order_id;
       if (this.store.isOrderSynced) {
-        console.log("[Checkout] 订单已同步过，将执行更新操作");
+        this.logInfo("订单已同步过，将执行更新操作");
       }
-      console.log("[Checkout] 开始手动同步订单到后端:", {
+      this.logInfo("开始手动同步订单到后端:", {
         orderUuid,
         orderId: oldOrderId,
         totalAmount: this.store.currentOrder.total_amount,
         remainingAmount: await this.calculateRemainingAmountAsync()
       });
       const syncResult = await this.syncOrderToBackendWithReturn(true);
-      console.log("[Checkout] 手动同步订单完成:", {
+      this.logInfo("手动同步订单完成:", {
         orderUuid,
         syncResult,
         oldOrderId,
@@ -1500,24 +1073,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       const finalOrderId = this.store.currentOrder.order_id;
       const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId);
-      console.log("[Checkout] manualSyncOrderAsync 最终状态验证:", {
-        returnedOrderId: syncResult.orderId,
-        storedOrderId: finalOrderId,
-        storedIdIsVirtual: finalIsVirtual,
-        isConsistent: syncResult.orderId === finalOrderId,
-        syncStatus: this.store.isOrderSynced
-      });
       if (finalIsVirtual) {
-        console.error("[Checkout] 严重警告：手动同步完成后订单ID仍为虚拟ID！");
+        this.logError("严重警告：手动同步完成后订单ID仍为虚拟ID！");
       }
       if (syncResult.orderId !== finalOrderId) {
-        console.error(
+        this.logError(
           "[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！"
         );
       }
       return syncResult;
     } catch (error) {
-      console.error("[Checkout] 手动同步订单失败:", error);
+      this.logError("手动同步订单失败:", error);
       const errorMessage = error instanceof Error ? error.message : "同步失败";
       return {
         success: false,
@@ -1578,7 +1144,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async cancelCurrentOrderAsync(cancelReason) {
     var _a, _b;
     try {
-      console.log("[Checkout] 开始取消当前本地订单:", {
+      this.logInfo("开始取消当前本地订单:", {
         hasCurrentOrder: !!this.store.currentOrder,
         orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
         orderId: (_b = this.store.currentOrder) == null ? void 0 : _b.order_id,
@@ -1586,7 +1152,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         cancelReason
       });
       if (!this.store.currentOrder) {
-        console.log("[Checkout] 没有当前订单，无需取消");
+        this.logInfo("没有当前订单，无需取消");
         return {
           success: false,
           message: "没有当前订单可取消"
@@ -1596,7 +1162,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const currentOrderId = this.store.currentOrder.order_id;
       const isOrderSynced = this.store.isOrderSynced;
       if (isOrderSynced) {
-        console.log("[Checkout] 订单已同步到后端，不能取消:", {
+        this.logInfo("订单已同步到后端，不能取消:", {
           orderId: currentOrderId,
           orderUuid: currentOrderUuid
         });
@@ -1606,15 +1172,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           orderId: currentOrderId
         };
       }
-      console.log("[Checkout] 订单尚未同步，可以取消");
       try {
-        console.log("[Checkout] 删除本地订单数据");
+        this.logInfo("删除本地订单数据");
         await this.payment.deletePaymentOrderAsync(currentOrderUuid);
-        console.log("[Checkout] 本地订单数据删除成功");
+        this.logInfo("本地订单数据删除成功");
       } catch (error) {
-        console.warn("[Checkout] 删除本地订单数据失败，但继续执行:", error);
+        this.logWarning("删除本地订单数据失败，但继续执行:", error);
       }
-      console.log("[Checkout] 清理订单相关状态");
+      this.logInfo("清理订单相关状态");
       this.store.currentOrder = void 0;
       this.store.localOrderData = void 0;
       this.store.stateAmount = "0.00";
@@ -1622,7 +1187,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.store.isOrderSynced = false;
       this.store.currentCustomer = void 0;
       this.payment.wallet.clearAllCache();
-      console.log("[Checkout] 订单状态清理完成，currentOrder已释放");
+      this.logInfo("订单状态清理完成，currentOrder已释放");
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCancelled, {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
@@ -1631,7 +1196,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         // 只有未同步订单可以被取消
         timestamp: Date.now()
       });
-      console.log("[Checkout] 本地订单取消完成:", {
+      this.logInfo("本地订单取消完成:", {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
         cancelReason
@@ -1642,7 +1207,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderId: currentOrderId
       };
     } catch (error) {
-      console.error("[Checkout] 取消本地订单失败:", error);
+      this.logError("取消本地订单失败:", error);
       const errorMessage = error instanceof Error ? error.message : "未知错误";
       return {
         success: false,
@@ -1667,7 +1232,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       }
       const orderUuid = this.store.currentOrder.uuid;
       const currentOrderId = this.store.currentOrder.order_id;
-      console.log("[Checkout] 开始保存订单并稍后支付:", {
+      this.logInfo("开始保存订单并稍后支付:", {
         orderUuid,
         orderId: currentOrderId,
         totalAmount: this.store.currentOrder.total_amount
@@ -1676,10 +1241,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.currentOrder.uuid
       );
       const syncResult = await this.syncOrderToBackendWithReturn(
-        false,
+        true,
         allPaymentItems
       );
-      console.log("[Checkout] 保存订单完成:", {
+      this.logInfo("保存订单完成:", {
         orderUuid,
         oldOrderId: currentOrderId,
         syncResult,
@@ -1687,13 +1252,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         isOrderSynced: this.store.isOrderSynced,
         filteredPaymentsCount: allPaymentItems.length
       });
-      const finalOrderId = this.store.currentOrder.order_id;
-      console.log("[Checkout] saveForLaterPaymentAsync 最终状态验证:", {
-        returnedOrderId: syncResult.orderId,
-        storedOrderId: finalOrderId,
-        isConsistent: syncResult.orderId === finalOrderId,
-        syncStatus: this.store.isOrderSynced
-      });
       return {
         success: true,
         message: "订单保存成功，可稍后继续支付",
@@ -1702,7 +1260,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         response: syncResult.response
       };
     } catch (error) {
-      console.error("[Checkout] 保存订单失败:", error);
+      this.logError("保存订单失败:", error);
       const errorMessage = error instanceof Error ? error.message : "保存失败";
       return {
         success: false,
@@ -1711,93 +1269,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       };
     }
   }
-  /**
-   * 获取当前商店折扣金额
-   *
-   * @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 = (0, import_utils.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;
-    }
-  }
   /**
    * 更新订单备注
    *
@@ -1853,40 +1324,15 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 设置状态
-   */
-  setStatus(status) {
-    const oldStatus = this.store.status;
-    this.store.status = status;
-    this.core.effects.emit(import_types.CheckoutHooks.OnStatusChanged, {
-      oldStatus,
-      newStatus: status,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * 设置步骤
-   */
-  setStep(step) {
-    const oldStep = this.store.step;
-    this.store.step = step;
-    this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
-      oldStep,
-      newStep: step,
-      timestamp: Date.now()
-    });
-  }
   /**
    * 处理错误
    */
   async handleError(error, type) {
     const checkoutError = error instanceof Error && "type" in error ? error : (0, import_utils.createCheckoutError)(type, error.message, error);
     this.store.lastError = checkoutError;
-    this.setStatus(import_types.CheckoutStatus.Error);
     await this.core.effects.emit(import_types.CheckoutHooks.OnError, {
       error: checkoutError,
-      context: { status: this.store.status, step: this.store.step },
+      context: {},
       timestamp: Date.now()
     });
     console.error("[Checkout] 错误:", checkoutError);
@@ -1896,7 +1342,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async handlePaymentSuccess(data) {
     var _a;
-    this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
     await this.updateStateAmountToRemaining();
     await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentSuccess, {
       orderUuid: data.orderUuid,
@@ -1934,24 +1379,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 处理现金支付项的找零逻辑
-   * 
+   *
    * @param paymentItem 原始支付项
    * @returns 处理后的支付项（包含找零信息）
    */
   async processCashPaymentItem(paymentItem) {
-    const isCashPayment = this.isCashPayment(paymentItem.code, paymentItem.type);
-    if (!isCashPayment) {
+    const cashPayment = (0, import_utils.isCashPayment)(paymentItem.code, paymentItem.type);
+    if (!cashPayment) {
       return paymentItem;
     }
     try {
       const remainingAmountStr = await this.calculateRemainingAmountAsync();
       let remainingAmount = new import_decimal.default(remainingAmountStr);
       const cashAmount = new import_decimal.default(String(paymentItem.amount));
-      console.log("[Checkout] 现金支付处理:", {
-        cashAmount: cashAmount.toNumber(),
-        remainingAmount: remainingAmount.toNumber(),
-        needsChange: cashAmount.gt(remainingAmount)
-      });
       if (cashAmount.lte(remainingAmount)) {
         return paymentItem;
       }
@@ -1960,14 +1400,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         if (Number(paymentItem.rounding_amount) === changeAmount.toNumber()) {
           return paymentItem;
         } else {
-          remainingAmount = remainingAmount.add(new import_decimal.default(paymentItem.rounding_amount || "0"));
+          remainingAmount = remainingAmount.add(
+            new import_decimal.default(paymentItem.rounding_amount || "0")
+          );
         }
       }
-      console.log("[Checkout] 现金支付需要找零:", {
-        actualPaidAmount: cashAmount.toFixed(2),
-        chargedAmount: remainingAmount.toFixed(2),
-        changeGivenAmount: changeAmount.toFixed(2)
-      });
       const processedPaymentItem = {
         ...paymentItem,
         amount: remainingAmount.toFixed(2),
@@ -1995,25 +1432,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       return processedPaymentItem;
     } catch (error) {
-      console.error("[Checkout] 处理现金支付项时出错:", error);
+      this.logError("处理现金支付项时出错:", error);
       return paymentItem;
     }
   }
-  /**
-   * 判断是否为现金支付
-   * 
-   * @param paymentCode 支付代码
-   * @param paymentType 支付类型
-   * @returns 是否为现金支付
-   */
-  isCashPayment(paymentCode, paymentType) {
-    const codeUpper = (paymentCode == null ? void 0 : paymentCode.toUpperCase()) || "";
-    const typeUpper = (paymentType == null ? void 0 : paymentType.toUpperCase()) || "";
-    const cashIdentifiers = ["CASH", "CASHMANUAL", "MANUAL"];
-    return cashIdentifiers.some(
-      (identifier) => codeUpper.includes(identifier) || typeUpper.includes(identifier)
-    );
-  }
   /**
    * 预加载支付方式（在初始化时调用）
    */
@@ -2030,7 +1452,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 清理过期的已同步订单数据
-   * 
+   *
    * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
    */
   async cleanupExpiredOrdersAsync() {
@@ -2044,7 +1466,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         console.log("[Checkout] 订单数据清理功能已禁用");
         return;
       }
-      console.log(`[Checkout] 开始清理过期订单数据（保留 ${retentionDays} 天内的数据）...`);
+      console.log(
+        `[Checkout] 开始清理过期订单数据（保留 ${retentionDays} 天内的数据）...`
+      );
       const allOrders = await this.payment.getOrderListAsync();
       if (!allOrders || allOrders.length === 0) {
         console.log("[Checkout] 没有找到需要清理的订单数据");
@@ -2064,7 +1488,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           if ((_a = order.order_info) == null ? void 0 : _a.created_at) {
             orderCreatedAt = new Date(order.order_info.created_at);
           } else if ((_c = (_b = order.order_info) == null ? void 0 : _b.original_order_data) == null ? void 0 : _c.created_at) {
-            orderCreatedAt = new Date(order.order_info.original_order_data.created_at);
+            orderCreatedAt = new Date(
+              order.order_info.original_order_data.created_at
+            );
           }
           if (!orderCreatedAt || isNaN(orderCreatedAt.getTime())) {
             continue;
@@ -2074,7 +1500,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
               uuid: order.uuid,
               orderId: order.order_id,
               createdAt: orderCreatedAt.toISOString(),
-              daysSinceCreated: Math.floor((Date.now() - orderCreatedAt.getTime()) / (1e3 * 60 * 60 * 24))
+              daysSinceCreated: Math.floor(
+                (Date.now() - orderCreatedAt.getTime()) / (1e3 * 60 * 60 * 24)
+              )
             });
           }
         } catch (error) {
@@ -2082,13 +1510,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           continue;
         }
       }
-      ordersToDelete.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      ordersToDelete.sort(
+        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+      );
       const actualOrdersToDelete = ordersToDelete.slice(0, maxOrdersToDelete);
       for (const orderInfo of actualOrdersToDelete) {
         try {
           await this.payment.deletePaymentOrderAsync(orderInfo.uuid);
           deletedCount++;
-          console.log(`[Checkout] 已删除过期订单: ${orderInfo.orderId} (${orderInfo.daysSinceCreated} 天前创建)`);
+          console.log(
+            `[Checkout] 已删除过期订单: ${orderInfo.orderId} (${orderInfo.daysSinceCreated} 天前创建)`
+          );
         } catch (error) {
           console.error(`[Checkout] 删除订单 ${orderInfo.uuid} 失败:`, error);
         }
@@ -2105,9 +1537,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       };
       this.logInfo("Expired orders cleanup completed", summary);
       if (ordersToDelete.length > maxOrdersToDelete) {
-        console.log(`[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，发现 ${ordersToDelete.length} 个过期已同步订单，删除了 ${deletedCount} 个（限制为 ${maxOrdersToDelete} 个）`);
+        console.log(
+          `[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，发现 ${ordersToDelete.length} 个过期已同步订单，删除了 ${deletedCount} 个（限制为 ${maxOrdersToDelete} 个）`
+        );
       } else {
-        console.log(`[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，删除了 ${deletedCount} 个过期已同步订单`);
+        console.log(
+          `[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，删除了 ${deletedCount} 个过期已同步订单`
+        );
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2120,7 +1556,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async calculatePaidAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculatePaidAmountAsync: 没有当前订单");
+      this.logWarning("[Checkout] calculatePaidAmountAsync: 没有当前订单");
       return "0.00";
     }
     try {
@@ -2129,16 +1565,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         false
         // 不包括已撤销的支付项
       );
-      console.log("[Checkout] calculatePaidAmountAsync: 支付项详情:", {
-        paymentCount: payments.length,
-        payments: payments.map((p) => ({
-          uuid: p.uuid,
-          amount: p.amount,
-          code: p.code,
-          status: p.status,
-          rounding_amount: p.rounding_amount
-        }))
-      });
       const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
         const amount = new import_decimal.default(payment.amount || "0");
         const roundingAmount = new import_decimal.default(payment.rounding_amount || "0");
@@ -2158,10 +1584,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         return sum.add(effectiveAmount);
       }, new import_decimal.default(0));
       const result = paidAmount.toFixed(2);
-      console.log("[Checkout] calculatePaidAmountAsync: 计算结果 =", result);
+      this.logInfo("calculatePaidAmountAsync: 计算结果 =", result);
       return result;
     } catch (error) {
-      console.error("[Checkout] calculatePaidAmountAsync 失败:", error);
+      this.logError("calculatePaidAmountAsync 失败:", error);
       return "0.00";
     }
   }
@@ -2170,45 +1596,26 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async calculateRemainingAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculateRemainingAmountAsync: 没有当前订单");
+      this.logWarning("calculateRemainingAmountAsync: 没有当前订单");
       return "0.00";
     }
-    const totalAmount = new import_decimal.default(this.store.currentOrder.total_amount || "0");
+    const totalAmount = new import_decimal.default(
+      this.store.currentOrder.total_amount || "0"
+    );
     const paidAmountStr = await this.calculatePaidAmountAsync();
     const paidAmount = new import_decimal.default(paidAmountStr);
     const remainingAmount = totalAmount.sub(paidAmount);
     const result = import_decimal.default.max(0, remainingAmount).toFixed(2);
-    console.log("[Checkout] calculateRemainingAmountAsync: 计算详情:", {
-      orderUuid: this.store.currentOrder.uuid,
-      totalAmount: totalAmount.toFixed(2),
-      paidAmount: paidAmount.toFixed(2),
-      calculatedRemaining: remainingAmount.toFixed(2),
-      finalResult: result,
-      description: "已支付金额包含抹零计算（amount + |rounding_amount|）",
-      // Decimal 精度验证
-      preciseCalculationValues: {
-        totalAmount: totalAmount.toString(),
-        paidAmount: paidAmount.toString(),
-        remainingAmount: remainingAmount.toString(),
-        resultAfterMax: import_decimal.default.max(0, remainingAmount).toString()
-      }
-    });
+    this.logInfo("calculateRemainingAmountAsync: 计算=", result);
     return result;
   }
   /**
    * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
    */
   async updateBalanceDueAmount() {
-    var _a;
     try {
       const remainingAmount = await this.calculateRemainingAmountAsync();
       const currentBalanceDueAmount = this.store.balanceDueAmount;
-      console.log("[Checkout] updateBalanceDueAmount: 状态检查:", {
-        calculatedRemainingAmount: remainingAmount,
-        currentBalanceDueAmount,
-        needsUpdate: remainingAmount !== currentBalanceDueAmount,
-        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
-      });
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
         await this.core.effects.emit(import_types.CheckoutHooks.OnBalanceDueAmountChanged, {
@@ -2216,34 +1623,27 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           newAmount: remainingAmount,
           timestamp: Date.now()
         });
-        console.log("[Checkout] balanceDueAmount 已自动更新:", {
+        this.logInfo("balanceDueAmount 已自动更新:", {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount
         });
       } else {
-        console.log("[Checkout] balanceDueAmount 无需更新，当前值已是最新:", {
+        this.logInfo("balanceDueAmount 无需更新，当前值已是最新:", {
           balanceDueAmount: currentBalanceDueAmount,
           remainingAmount
         });
       }
     } catch (error) {
-      console.error("[Checkout] 更新 balanceDueAmount 失败:", error);
+      this.logError("更新 balanceDueAmount 失败:", error);
     }
   }
   /**
    * 更新 stateAmount 为当前剩余未支付金额
    */
   async updateStateAmountToRemaining() {
-    var _a;
     try {
       const remainingAmount = await this.calculateRemainingAmountAsync();
       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;
         this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
@@ -2251,12 +1651,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           newAmount: remainingAmount,
           timestamp: Date.now()
         });
-        console.log("[Checkout] stateAmount 已自动更新为剩余金额:", {
+        this.logInfo("stateAmount 已自动更新为剩余金额:", {
           oldAmount: currentStateAmount,
           newAmount: remainingAmount
         });
       } else {
-        console.log("[Checkout] stateAmount 无需更新，当前值已是最新:", {
+        this.logInfo("stateAmount 无需更新，当前值已是最新:", {
           stateAmount: currentStateAmount,
           remainingAmount
         });
@@ -2264,7 +1664,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       await this.updateBalanceDueAmount();
       await this.checkOrderPaymentCompletion();
     } catch (error) {
-      console.error("[Checkout] 更新 stateAmount 为剩余金额失败:", error);
+      this.logError("更新 stateAmount 为剩余金额失败:", error);
     }
   }
   /**
@@ -2282,7 +1682,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       if (remainingValue.lte(0)) {
         const totalAmount = this.store.currentOrder.total_amount;
         const paidAmount = await this.calculatePaidAmountAsync();
-        console.log("[Checkout] 检测到订单支付完成:", {
+        this.logInfo("检测到订单支付完成:", {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2300,7 +1700,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           (item) => item.status !== "voided" && item.voucher_id
         );
         const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
-        console.log("[Checkout] 自动同步订单条件检查:", {
+        this.logInfo("自动同步订单条件检查:", {
           paymentCount: currentPayments.length,
           hasPaymentItems,
           allHaveVoucherId: allPaymentsHaveVoucherId,
@@ -2318,13 +1718,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           }))
         });
         if (shouldAutoSync) {
-          console.log("[Checkout] 满足自动同步条件，开始同步订单到后端...");
-          await this.syncOrderToBackend();
+          this.logInfo("满足自动同步条件，开始同步订单到后端...");
+          await this.syncOrderToBackendWithReturn(false);
         } else {
           if (!hasPaymentItems) {
-            console.log("[Checkout] 没有支付项，跳过订单同步");
+            this.logInfo("没有支付项，跳过订单同步");
           } else if (allPaymentsHaveVoucherId) {
-            console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
+            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
           }
         }
         await this.core.effects.emit(import_types.CheckoutHooks.OnOrderPaymentCompleted, {
@@ -2337,14 +1737,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         });
       }
     } catch (error) {
-      console.error("[Checkout] 检查订单支付完成状态失败:", error);
+      this.logError("检查订单支付完成状态失败:", error);
     }
   }
-  /**
-   * 同步订单到后端
-   *
-   * 调用后端 /order/checkout 接口创建真实订单
-   */
   /**
    * 同步订单到后端并返回真实订单ID
    *
@@ -2353,72 +1748,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 包含订单ID、UUID和完整后端响应的对象
    */
   async syncOrderToBackendWithReturn(isManual = false, customPaymentItems) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    var _a, _b, _c, _d, _e, _f;
     if (!this.store.localOrderData || !this.store.currentOrder) {
       throw new Error("缺少必要的订单数据，无法同步到后端");
     }
-    this.logInfo("syncOrderToBackendWithReturn called", {
-      isManual,
-      hasCustomPaymentItems: !!customPaymentItems,
-      customPaymentItemsCount: (customPaymentItems == null ? void 0 : customPaymentItems.length) || 0,
-      currentOrderId: this.store.currentOrder.order_id,
-      orderUuid: this.store.currentOrder.uuid,
-      isOrderSynced: this.store.isOrderSynced,
-      isVirtualOrderId: (0, import_utils.isVirtualOrderId)(this.store.currentOrder.order_id),
-      localOrderDataType: this.store.localOrderData.type,
-      platform: this.store.localOrderData.platform,
-      customerId: (_a = this.store.currentCustomer) == null ? void 0 : _a.customer_id
-    });
-    const syncType = isManual ? "手动" : "自动";
+    this.logInfo("syncOrderToBackendWithReturn called", { isManual });
     const currentOrderId = this.store.currentOrder.order_id;
-    const hasRealOrderId = currentOrderId && !(0, import_utils.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}订单到后端...`, {
+    const isUpdateOperation = this.store.isOrderSynced || !(0, import_utils.isVirtualOrderId)(currentOrderId);
+    this.logInfo(`开始同步订单到后端...`, {
       currentOrderId,
       isVirtualId: (0, import_utils.isVirtualOrderId)(currentOrderId || ""),
-      operation,
       orderUuid: this.store.currentOrder.uuid,
-      isOrderSynced: this.store.isOrderSynced
+      isOrderSynced: this.store.isOrderSynced,
+      isManual
     });
     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,
-          orderPaymentType: p.order_payment_type,
-          metadata: p.metadata
-        };
-      })
-    });
     const processedPaymentItems = paymentItems.map((item) => {
       var _a2, _b2;
       return {
@@ -2430,23 +1774,55 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
       };
     });
-    console.log("[Checkout] 处理后的支付项数据（包含完整metadata）:", {
-      originalCount: paymentItems.length,
-      processedCount: processedPaymentItems.length,
-      sampleMetadata: (_b = processedPaymentItems[0]) == null ? void 0 : _b.metadata,
-      allPaymentItems: processedPaymentItems.map((p) => {
-        var _a2, _b2;
-        return {
-          code: p.code,
-          amount: p.amount,
-          voucherId: p.voucher_id,
-          orderPaymentType: p.order_payment_type,
-          metadata: p.metadata,
-          // 现金支付找零信息
-          actualPaidAmount: (_a2 = p.metadata) == null ? void 0 : _a2.actual_paid_amount,
-          changeGivenAmount: (_b2 = p.metadata) == null ? void 0 : _b2.change_given_amount
-        };
-      })
+    let finalDepositAmount;
+    const manualDepositAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.deposit_amount) || "0.00";
+    const depositPaymentItems = processedPaymentItems.filter(
+      (item) => item.order_payment_type === "deposit" && item.status !== "voided"
+    );
+    const calculatedDepositAmount = depositPaymentItems.reduce((sum, item) => {
+      const amount = new import_decimal.default(item.amount || "0");
+      const roundingAmount = new import_decimal.default(item.rounding_amount || "0");
+      const effectiveAmount = amount.add(roundingAmount.abs());
+      return sum.add(effectiveAmount);
+    }, new import_decimal.default(0)).toFixed(2);
+    const manualDepositValue = new import_decimal.default(manualDepositAmount);
+    const calculatedDepositValue = new import_decimal.default(calculatedDepositAmount);
+    if (manualDepositValue.gt(0)) {
+      finalDepositAmount = manualDepositAmount;
+      this.logInfo("使用手动设置的定金金额", {
+        manualDepositAmount,
+        calculatedDepositAmount,
+        reason: "用户通过setDepositAmountAsync手动设置了定金金额"
+      });
+    } else if (calculatedDepositValue.gt(0)) {
+      finalDepositAmount = calculatedDepositAmount;
+      this.logInfo("使用从支付项计算的定金金额", {
+        manualDepositAmount,
+        calculatedDepositAmount,
+        reason: "未手动设置定金金额，从定金类型支付项计算得出"
+      });
+    } else {
+      finalDepositAmount = "0.00";
+      this.logInfo("定金金额为0", {
+        manualDepositAmount,
+        calculatedDepositAmount,
+        reason: "手动设置和计算值均为0"
+      });
+    }
+    this.logInfo("定金金额确定结果", {
+      depositPaymentItemsCount: depositPaymentItems.length,
+      depositPaymentItems: depositPaymentItems.map((item) => ({
+        uuid: item.uuid,
+        code: item.code,
+        amount: item.amount,
+        rounding_amount: item.rounding_amount,
+        order_payment_type: item.order_payment_type,
+        status: item.status
+      })),
+      manualDepositAmount,
+      calculatedDepositAmount,
+      finalDepositAmount,
+      isDeposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit) || 0
     });
     const orderParams = {
       ...this.store.localOrderData,
@@ -2468,34 +1844,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       currency_symbol: this.otherParams.currency_symbol,
       currency_format: this.otherParams.currency_format,
       is_deposit: ((_d = this.store.currentOrder) == null ? void 0 : _d.is_deposit) || 0,
-      deposit_amount: ((_e = this.store.currentOrder) == null ? void 0 : _e.deposit_amount) || "0.00",
-      // surcharge_fee: this.otherParams.surcharge_fee,
-      // surcharges: ,
+      deposit_amount: finalDepositAmount,
+      // 使用最终确定的定金金额（手动设置优先）
       product_tax_fee: this.store.localOrderData.tax_fee,
       note: this.store.localOrderData.shop_note
-      // deposit_amount:
     };
     if (isUpdateOperation) {
       if ((0, import_utils.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] 注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
+        this.logWarning(
+          "尝试数据修复：暂时不包含order_id，注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
         );
       } else {
         orderParams.order_id = currentOrderId;
-        console.log(`[Checkout] 更新订单操作，包含订单ID: ${currentOrderId}`);
       }
-    } else {
-      console.log("[Checkout] 创建新订单操作");
     }
     const startTime = Date.now();
     await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSubmitStart, {
@@ -2511,29 +1872,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     try {
       this.logInfo("Calling backend checkout API", {
         url: "/order/checkout",
-        operation,
         isManual,
-        orderType: orderParams.type,
-        platform: orderParams.platform,
-        customerId: orderParams.customer_id,
-        isDeposit: orderParams.is_deposit,
-        depositAmount: orderParams.deposit_amount,
-        bookingsCount: ((_f = orderParams.bookings) == null ? void 0 : _f.length) || 0,
-        relationProductsCount: ((_g = orderParams.relation_products) == null ? void 0 : _g.length) || 0,
-        paymentsCount: ((_h = orderParams.payments) == null ? void 0 : _h.length) || 0,
-        paymentMethods: ((_i = orderParams.payments) == null ? void 0 : _i.map((p) => p.code)) || [],
-        hasOrderId: !!orderParams.order_id,
-        orderIdIncluded: orderParams.order_id,
-        productTaxFee: orderParams.product_tax_fee,
-        note: orderParams.note,
-        scheduleDate: orderParams.schedule_date
+        ...orderParams
       });
       checkoutResponse = await this.order.createOrderByCheckout(orderParams);
       submitSuccess = true;
-      console.log("[Checkout] 下单接口调用成功");
+      this.logInfo("下单接口调用成功", checkoutResponse);
     } catch (error) {
       submitSuccess = false;
       submitError = error instanceof Error ? error.message : String(error);
+      this.logError("下单接口调用失败:", submitError);
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
@@ -2550,29 +1898,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
         isManual,
-        orderId: submitSuccess ? ((_j = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _j.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
+        orderId: submitSuccess ? ((_e = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _e.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
         error: submitError,
         duration: Date.now() - startTime,
         timestamp: Date.now()
       });
     }
-    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
-    });
     const responseStatus = checkoutResponse == null ? void 0 : checkoutResponse.status;
     const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === "success" || responseStatus === 1 && (checkoutResponse == null ? void 0 : checkoutResponse.code) === 200;
     if (!isSuccessResponse) {
       const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
-      console.error("[Checkout] 订单同步失败，响应状态检查未通过:", {
-        expectedSuccess: true,
-        actualStatus: responseStatus,
-        code: checkoutResponse == null ? void 0 : checkoutResponse.code,
-        message: checkoutResponse == null ? void 0 : checkoutResponse.message,
-        errorMessage
-      });
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
@@ -2585,13 +1920,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       throw new Error(errorMessage);
     }
-    console.log("[Checkout] 响应状态检查通过，开始处理订单数据");
     let realOrderId;
     if (isUpdateOperation) {
       realOrderId = currentOrderId;
-      console.log(`[Checkout] 订单更新成功，订单ID: ${realOrderId}`);
     } else {
-      let extractedOrderId = (_k = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _k.order_id;
+      let extractedOrderId = (_f = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _f.order_id;
       if (!extractedOrderId) {
         extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
       }
@@ -2599,11 +1932,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         extractedOrderId = String(extractedOrderId);
       }
       if (!extractedOrderId) {
-        throw new Error("后端返回的订单信息中未包含订单ID");
+        this.logError("后端返回的订单信息中未包含订单ID");
       }
       realOrderId = extractedOrderId;
-      console.log("[Checkout] 订单创建成功，真实订单ID:", realOrderId);
-      console.log("[Checkout] 准备替换订单ID:", {
+      this.logInfo("准备替换订单ID:", {
         orderUuid: this.store.currentOrder.uuid,
         oldOrderId: this.store.currentOrder.order_id,
         newOrderId: realOrderId
@@ -2613,38 +1945,38 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           this.store.currentOrder.uuid,
           realOrderId
         );
-        console.log("[Checkout] Payment模块替换订单ID结果:", {
+        this.logInfo("Payment模块替换订单ID结果:", {
           wasSuccessful: !!updatedOrder,
           returnedOrderId: updatedOrder == null ? void 0 : updatedOrder.order_id,
           expectedOrderId: realOrderId
         });
         if (updatedOrder) {
-          console.log("[Checkout] Payment模块返回的更新后订单:", {
+          this.logInfo("Payment模块返回的更新后订单:", {
             uuid: updatedOrder.uuid,
             orderId: updatedOrder.order_id,
             totalAmount: updatedOrder.total_amount
           });
           this.store.currentOrder = updatedOrder;
-          console.log(
+          this.logInfo(
             "[Checkout] 订单ID替换成功，当前订单ID:",
             this.store.currentOrder.order_id
           );
         } else {
-          console.error(
+          this.logError(
             "[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换"
           );
           const beforeManualUpdate = this.store.currentOrder.order_id;
           this.store.currentOrder.order_id = realOrderId;
-          console.log("[Checkout] 手动设置订单ID:", {
+          this.logInfo("手动设置订单ID:", {
             beforeReplacement: beforeManualUpdate,
             afterReplacement: this.store.currentOrder.order_id,
             目标ID: realOrderId
           });
         }
       } catch (error) {
-        console.error("[Checkout] 调用Payment模块替换订单ID时发生错误:", error);
+        this.logError("调用Payment模块替换订单ID时发生错误:", error);
         this.store.currentOrder.order_id = realOrderId;
-        console.log("[Checkout] 错误恢复：手动设置订单ID:", realOrderId);
+        this.logInfo("错误恢复：手动设置订单ID:", realOrderId);
       }
     }
     this.store.isOrderSynced = true;
@@ -2656,69 +1988,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       isManual,
       response: checkoutResponse
     });
-    const finalOrderId = this.store.currentOrder.order_id;
-    const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId || "");
-    console.log(`[Checkout] ${syncType}${operation}订单到后端完成`, {
-      returnedOrderId: realOrderId,
-      currentStoredOrderId: finalOrderId,
-      isStillVirtualId: finalIsVirtual,
-      isSynced: this.store.isOrderSynced
-    });
-    if (finalIsVirtual && !isUpdateOperation) {
-      console.warn(
-        "[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题"
-      );
-    }
     return {
       success: true,
-      message: `订单${operation}成功`,
       orderId: realOrderId,
       orderUuid: this.store.currentOrder.uuid,
       response: checkoutResponse
     };
   }
-  async syncOrderToBackend() {
-    try {
-      const syncResult = await this.syncOrderToBackendWithReturn(false);
-      console.log("[Checkout] 自动同步订单完成:", syncResult);
-    } catch (error) {
-      console.error("[Checkout] 同步订单到后端失败:", error);
-      await this.handleError(
-        new Error(
-          `订单同步失败: ${error instanceof Error ? error.message : String(error)}`
-        ),
-        import_types.CheckoutErrorType.OrderCreationFailed
-      );
-    }
-  }
-  /**
-   * 获取状态消息
-   */
-  getStatusMessage() {
-    var _a;
-    switch (this.store.status) {
-      case import_types.CheckoutStatus.Initializing:
-        return "正在初始化结账流程...";
-      case import_types.CheckoutStatus.Ready:
-        return "准备就绪，可以开始结账";
-      case import_types.CheckoutStatus.CreatingOrder:
-        return "正在创建订单...";
-      case import_types.CheckoutStatus.OrderCreated:
-        return "订单创建成功，请选择支付方式";
-      case import_types.CheckoutStatus.ProcessingPayment:
-        return "正在处理支付...";
-      case import_types.CheckoutStatus.PaymentCompleted:
-        return "支付完成";
-      case import_types.CheckoutStatus.Completed:
-        return "结账完成";
-      case import_types.CheckoutStatus.Cancelled:
-        return "结账已取消";
-      case import_types.CheckoutStatus.Error:
-        return ((_a = this.store.lastError) == null ? void 0 : _a.message) || "发生未知错误";
-      default:
-        return "";
-    }
-  }
   async setOtherParams(params, { cover = false } = {}) {
     if (cover) {
       this.otherParams = params;
@@ -2739,15 +2015,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     this.logInfo("editOrderNoteByOrderIdAsync called", {
       orderId,
       note,
-      noteLength: note.length,
-      isCurrentOrder: this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId))
+      noteLength: note.length
     });
     try {
-      console.log("[Checkout] 开始编辑订单备注:", {
-        orderId,
-        note,
-        noteLength: note.length
-      });
       if (!orderId) {
         return {
           success: false,
@@ -2762,22 +2032,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         note,
         noteLength: note.length
       });
-      const response = await this.request.put(
-        `/order/order/${orderId}/note`,
-        {
-          note
-        }
-      );
-      console.log("[Checkout] 订单备注编辑响应:", {
+      const response = await this.request.put(`/order/order/${orderId}/note`, {
+        note
+      });
+      this.logInfo("订单备注编辑响应:", {
         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;
@@ -2796,7 +2061,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         };
       } else {
         const errorMessage = response.message || "订单备注修改失败";
-        console.error(`[Checkout] 订单 ${orderId} 备注修改失败:`, errorMessage);
+        this.logError(`订单 ${orderId} 备注修改失败:`, errorMessage);
         return {
           success: false,
           message: errorMessage,
@@ -2804,7 +2069,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         };
       }
     } catch (error) {
-      console.error("[Checkout] 编辑订单备注失败:", error);
+      this.logError("编辑订单备注失败:", error);
       const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
       return {
         success: false,
@@ -2831,11 +2096,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       notifyAction: params.notify_action || "order_payment_reminder"
     });
     try {
-      console.log("[Checkout] 开始发送客户支付链接邮件:", {
-        orderIds: params.order_ids,
-        emails: params.emails,
-        notifyAction: params.notify_action || "order_payment_reminder"
-      });
       if (!params.order_ids || params.order_ids.length === 0) {
         return {
           success: false,
@@ -2863,27 +2123,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         notify_action: params.notify_action || "order_payment_reminder",
         emails: params.emails
       };
-      console.log("[Checkout] 发送支付链接邮件请求参数:", requestBody);
       this.logInfo("Calling batch email API", {
         url: "/order/batch-email",
-        orderIds: requestBody.order_ids,
-        orderIdsCount: requestBody.order_ids.length,
-        notifyAction: requestBody.notify_action,
-        emails: requestBody.emails,
-        emailsCount: requestBody.emails.length
+        ...requestBody
       });
       const response = await this.request.post(
         "/order/batch-email",
         requestBody
       );
-      console.log("[Checkout] 支付链接邮件发送响应:", {
+      this.logInfo("支付链接邮件发送响应:", {
         status: response.status,
         message: response.message,
         data: response.data,
         response
       });
       if (response.status === true || response.status === 200) {
-        console.log("[Checkout] 支付链接邮件发送成功");
         return {
           success: true,
           message: response.message || "支付链接邮件发送成功"
@@ -2897,7 +2151,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         };
       }
     } catch (error) {
-      console.error("[Checkout] 发送客户支付链接邮件失败:", error);
+      this.logError("发送客户支付链接邮件失败:", error);
       const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
       return {
         success: false,
@@ -2918,9 +2172,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       (_a = this.otherParams.order_rounding_setting) == null ? void 0 : _a.interval,
       (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.type
     );
-    console.log(
-      `[Checkout] 金额舍入完成 - 原始: ${result.originalAmount}, 舍入后: ${result.roundedAmount}, 差额: ${result.roundingDifference}`
-    );
     return result;
   }
   async destroy() {
@@ -2954,8 +2205,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.store.lastError = void 0;
       this.store.cartItems = [];
       this.payment.wallet.clearAllCache();
-      this.setStatus(import_types.CheckoutStatus.Ready);
-      this.setStep(import_types.CheckoutStep.OrderConfirmation);
       console.log("[Checkout] Store 状态重置完成");
       if (prevOrderInfo) {
         await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCleared, {
@@ -2967,33 +2216,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.error("[Checkout] 重置 store 状态失败:", error);
     }
   }
-  /**
-   * 手动清理已完成的订单状态（公开方法）
-   *
-   * 供UI层调用的公开方法，用于手动清理订单状态
-   *
-   * @returns 清理结果
-   */
-  async clearCompletedOrderAsync() {
-    try {
-      const prevOrderInfo = this.store.currentOrder ? {
-        uuid: this.store.currentOrder.uuid,
-        orderId: this.store.currentOrder.order_id
-      } : null;
-      await this.resetStoreStateAsync();
-      return {
-        success: true,
-        message: prevOrderInfo ? "订单状态已成功清理" : "没有需要清理的订单状态",
-        clearedOrder: prevOrderInfo
-      };
-    } catch (error) {
-      console.error("[Checkout] 手动清理订单状态失败:", error);
-      return {
-        success: false,
-        message: error instanceof Error ? error.message : "清理失败"
-      };
-    }
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {