@pisell/pisellos 2.1.7 → 2.1.9

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()
@@ -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);
@@ -216,12 +210,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         selling_price: item.product.price - (item.product.discount_amount || 0) - getDiscountListAmount(item.product.discount_list)
       })
     )) || [];
-    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) {
@@ -242,6 +238,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     await this.payment.wallet.initializeWalletDataFromBusinessAsync(
       walletBusinessData
     );
+    if (!this.store.currentOrder) {
+      return;
+    }
     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 +272,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 +317,16 @@ 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,
@@ -354,206 +347,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 +368,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 +383,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 +397,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 +409,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 +420,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 +438,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()
-    });
-  }
   /**
    * 获取订单模块
    */
@@ -900,10 +525,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 +553,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   getBalanceDueAmount() {
     return this.store.balanceDueAmount;
   }
-  /**
-   * 刷新 stateAmount 为当前剩余未支付金额
-   *
-   * UI 可以调用此方法来主动刷新支付金额状态
-   */
-  async refreshStateAmountAsync() {
-    await this.updateStateAmountToRemaining();
-  }
   /**
    * 获取购物车小计数据
    *
@@ -952,7 +565,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 +575,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 +585,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 +612,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,53 +633,33 @@ 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 支付检查:", {
+      this.logInfo("支付项添加成功");
+      const isEftposPayment = ((_a = paymentItem.type) == null ? void 0 : _a.toLowerCase()) === "eftpos" || ((_b = paymentItem.code) == null ? void 0 : _b.toUpperCase().includes("EFTPOS"));
+      this.logInfo("EFTPOS 支付检查:", {
         paymentCode: paymentItem.code,
         paymentType: paymentItem.type,
         isEftposPayment,
         currentOrderSynced: this.store.isOrderSynced
       });
       if (isEftposPayment) {
-        console.log("[Checkout] 检测到 EFTPOS 支付，立即同步订单到后端...");
+        this.logInfo("检测到 EFTPOS 支付，立即同步订单到后端...");
         try {
           const syncResult = await this.syncOrderToBackendWithReturn(true);
-          console.log("[Checkout] EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
+          this.logInfo("EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
             orderId: syncResult.orderId,
             isOrderSynced: this.store.isOrderSynced,
             backendResponse: syncResult.response
           });
         } catch (error) {
-          console.error("[Checkout] EFTPOS 支付后订单同步失败:", error);
+          this.logError("EFTPOS 支付后订单同步失败:", error);
           await this.handleError(
-            new Error(`EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
+            new Error(
+              `EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`
+            ),
             import_types.CheckoutErrorType.OrderCreationFailed
           );
         }
@@ -1108,7 +672,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         timestamp: Date.now()
       });
     } catch (error) {
-      console.error("[Checkout] 添加支付项失败:", error);
+      this.logError("添加支付项失败:", error);
       await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
@@ -1130,7 +694,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "当前没有活跃订单，无法删除支付项"
         );
       }
-      console.log("[Checkout] 开始删除支付项:", {
+      this.logWarning("开始删除支付项:", {
         orderUuid: this.store.currentOrder.uuid,
         paymentUuid
       });
@@ -1146,7 +710,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 +720,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 +728,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 +738,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 +747,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 +771,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           "当前没有活跃订单，无法更新代金券支付项"
         );
       }
-      console.log("[Checkout] 开始批量更新代金券支付项:", {
-        orderUuid: this.store.currentOrder.uuid,
-        newVoucherCount: voucherPaymentItems.length,
+      this.logInfo("开始批量更新代金券支付项:", {
         voucherPaymentItems
       });
       const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
@@ -1236,16 +793,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 +804,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 +814,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 +822,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 +857,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 +879,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
@@ -1363,100 +892,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
-  /**
-   * 更新当前订单的客户信息
-   *
-   * 更新当前订单关联的客户信息，用于标识订单的所属客户
-   *
-   * @param customer 客户信息 (customer_id 和/或 customer_name)
-   * @throws 当前没有活跃订单时抛出错误
-   */
-  async updateOrderCustomerAsync(customer) {
-    try {
-      if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法更新客户信息"
-        );
-      }
-      console.log("[Checkout] 更新订单客户信息:", {
-        orderUuid: this.store.currentOrder.uuid,
-        oldCustomer: this.store.currentCustomer,
-        newCustomer: customer
-      });
-      this.store.currentCustomer = {
-        customer_id: customer.customer_id,
-        customer_name: customer.customer_name
-      };
-      if (this.store.localOrderData) {
-        this.store.localOrderData.customer_id = customer.customer_id;
-        this.store.localOrderData.customer_name = customer.customer_name;
-      }
-      console.log(
-        "[Checkout] 订单客户信息更新成功:",
-        this.store.currentCustomer
-      );
-    } catch (error) {
-      console.error("[Checkout] 更新订单客户信息失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
-      throw error;
-    }
-  }
-  /**
-   * 获取当前订单的客户信息
-   *
-   * @returns 当前客户信息，如果没有则返回 null
-   */
-  getCurrentCustomer() {
-    return this.store.currentCustomer || null;
-  }
-  /**
-   * 检查订单是否需要手动同步（异步版本）
-   *
-   * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
-   * 从 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 +917,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 +935,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 +1006,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 +1014,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         cancelReason
       });
       if (!this.store.currentOrder) {
-        console.log("[Checkout] 没有当前订单，无需取消");
+        this.logInfo("没有当前订单，无需取消");
         return {
           success: false,
           message: "没有当前订单可取消"
@@ -1596,7 +1024,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 +1034,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 +1049,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 +1058,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         // 只有未同步订单可以被取消
         timestamp: Date.now()
       });
-      console.log("[Checkout] 本地订单取消完成:", {
+      this.logInfo("本地订单取消完成:", {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
         cancelReason
@@ -1642,7 +1069,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 +1094,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
@@ -1679,7 +1106,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         false,
         allPaymentItems
       );
-      console.log("[Checkout] 保存订单完成:", {
+      this.logInfo("保存订单完成:", {
         orderUuid,
         oldOrderId: currentOrderId,
         syncResult,
@@ -1687,13 +1114,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 +1122,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 +1131,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 +1186,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 +1204,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 +1241,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 +1262,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 +1294,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 +1314,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 清理过期的已同步订单数据
-   * 
+   *
    * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
    */
   async cleanupExpiredOrdersAsync() {
@@ -2044,7 +1328,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 +1350,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 +1362,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 +1372,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 +1399,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 +1418,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 +1427,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 +1446,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 +1458,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 +1485,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 +1513,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 +1526,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 +1544,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 +1562,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 +1580,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 +1599,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         });
       }
     } catch (error) {
-      console.error("[Checkout] 检查订单支付完成状态失败:", error);
+      this.logError("检查订单支付完成状态失败:", error);
     }
   }
-  /**
-   * 同步订单到后端
-   *
-   * 调用后端 /order/checkout 接口创建真实订单
-   */
   /**
    * 同步订单到后端并返回真实订单ID
    *
@@ -2353,72 +1610,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;
     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 +1636,27 @@ 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
-        };
-      })
+    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);
+    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
+      })),
+      calculatedDepositAmount,
+      originalDepositAmount: ((_a = this.store.currentOrder) == null ? void 0 : _a.deposit_amount) || "0.00"
     });
     const orderParams = {
       ...this.store.localOrderData,
@@ -2454,7 +1664,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       platform: this.store.localOrderData.platform,
       payments: processedPaymentItems,
       // 使用处理过的支付项数据
-      customer_id: (_c = this.store.currentCustomer) == null ? void 0 : _c.customer_id,
+      customer_id: (_b = this.store.currentCustomer) == null ? void 0 : _b.customer_id,
       // 添加客户ID
       is_price_include_tax: this.otherParams.is_price_include_tax,
       // core 有
@@ -2467,35 +1677,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       currency_code: this.otherParams.currency_code,
       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: ,
+      is_deposit: ((_c = this.store.currentOrder) == null ? void 0 : _c.is_deposit) || 0,
+      deposit_amount: calculatedDepositAmount,
+      // 使用从支付项中计算出的定金金额
       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 +1706,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 +1732,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 ? ((_d = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _d.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 +1754,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 = (_e = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _e.order_id;
       if (!extractedOrderId) {
         extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
       }
@@ -2599,11 +1766,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 +1779,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 +1822,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 +1849,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 +1866,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 +1895,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 +1903,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 +1930,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 +1957,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 +1985,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 +2006,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 +2039,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 +2050,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 = {