@pisell/pisellos 2.1.28 → 2.1.30

package/lib/modules/Payment/index.js

@@ -323,48 +323,35 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       totalAmount: params.total_amount
     });
     try {
-      const existingOrder = await this.dbManager.get("order", params.order_id);
-      this.logInfo("createPaymentOrderAsync existingOrder", {
-        existingOrder
+      const newOrder = {
+        uuid: (0, import_utils.getUniqueId)("pay_order_"),
+        id: params.order_id,
+        order_id: params.order_id,
+        order_info: params.order_info,
+        payment_status: import_types.PaymentStatus.Processing,
+        payment: [],
+        adjust_offline_payments: [],
+        total_amount: params.total_amount,
+        expect_amount: params.total_amount,
+        tax_fee: "0.00",
+        is_deposit: params.is_deposit || 0,
+        deposit_amount: params.deposit_amount || "0.00"
+      };
+      const dbAddStartTime = Date.now();
+      await this.dbManager.add("order", newOrder);
+      const dbAddDuration = Date.now() - dbAddStartTime;
+      this.logInfo("Database add operation completed", {
+        operation: "dbManager.add",
+        table: "order",
+        orderUuid: newOrder.uuid,
+        orderId: newOrder.order_id,
+        duration: `${dbAddDuration}ms`,
+        performance: dbAddDuration > 100 ? "slow" : dbAddDuration > 50 ? "medium" : "fast"
       });
-      if (existingOrder) {
-        this.logInfo(
-          `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`
-        );
-        existingOrder.order_info = params.order_info;
-        existingOrder.total_amount = params.total_amount;
-        existingOrder.is_deposit = params.is_deposit || 0;
-        existingOrder.deposit_amount = params.deposit_amount || "0.00";
-        this.recalculateOrderAmount(existingOrder);
-        await this.dbManager.update("order", existingOrder);
-        await this.core.effects.emit(
-          import_types.PaymentHooks.OnOrderUpdated,
-          existingOrder
-        );
-        return existingOrder;
-      } else {
-        const newOrder = {
-          uuid: (0, import_utils.getUniqueId)("pay_order_"),
-          id: params.order_id,
-          order_id: params.order_id,
-          order_info: params.order_info,
-          payment_status: import_types.PaymentStatus.Processing,
-          payment: [],
-          adjust_offline_payments: [],
-          total_amount: params.total_amount,
-          expect_amount: params.total_amount,
-          tax_fee: "0.00",
-          is_deposit: params.is_deposit || 0,
-          deposit_amount: params.deposit_amount || "0.00"
-        };
-        await this.dbManager.add("order", newOrder);
-        this.core.effects.emit(import_types.PaymentHooks.OnOrderAdded, newOrder);
-        this.logInfo("createPaymentOrderAsync completed - new payment order created", {
-          orderUuid: newOrder.uuid,
-          orderId: newOrder.id
-        });
-        return newOrder;
-      }
+      setTimeout(() => {
+        this.core.effects.emit(`${this.name}:onOrderAdded`, newOrder);
+      }, 0);
+      return newOrder;
     } catch (error) {
       console.error("[PaymentModule] 创建支付订单失败", error);
       this.logError("createPaymentOrderAsync failed", error, {
@@ -913,7 +900,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
           }
           const paymentAmount = new import_decimal.Decimal(payment.amount || 0);
           const roundingAmount = new import_decimal.Decimal(payment.rounding_amount || 0);
-          const effectiveAmount = paymentAmount.plus(roundingAmount.abs());
+          const effectiveAmount = paymentAmount.plus(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
           return sum.plus(effectiveAmount);
         } catch (error) {
           console.warn(`[PaymentModule] 无效的支付金额: amount=${payment.amount}, rounding_amount=${payment.rounding_amount}，跳过计算`);
@@ -935,7 +922,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         code: p.code,
         amount: p.amount,
         rounding_amount: p.rounding_amount || "0.00",
-        effective_amount: new import_decimal.Decimal(p.amount || 0).plus(new import_decimal.Decimal(p.rounding_amount || 0).abs()).toFixed(2)
+        effective_amount: new import_decimal.Decimal(p.amount || 0).plus(new import_decimal.Decimal(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || 0).abs()).toFixed(2)
       })),
       说明: "有效支付金额包含抹零计算（amount + |rounding_amount|）"
     });

package/lib/solution/Checkout/index.d.ts

@@ -19,6 +19,7 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private store;
     private otherParams;
     private logger;
+    private calculationCache;
     order: OrderModule;
     payment: PaymentModule;
     constructor(name?: string, version?: string);
@@ -302,26 +303,72 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
      */
     private cleanupExpiredOrdersAsync;
+    /**
+     * 清除计算缓存
+     */
+    private clearCalculationCache;
+    /**
+     * 批量获取订单数据（用于性能优化）
+     * 一次性获取所有需要的数据，避免重复查询
+     */
+    private fetchOrderDataBatch;
+    /**
+     * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+     */
+    private calculatePaidAmountFromItems;
     /**
      * 计算已支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculatePaidAmountAsync;
+    /**
+     * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
+     */
+    private calculateRemainingAmountFromData;
+    /**
+     * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+     */
+    private calculateRemainingTotalAmountFromData;
     /**
      * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingAmountAsync;
+    /**
+     * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
+     */
+    private calculateRemainingTotalAmountAsync;
     /**
      * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
      */
     private updateBalanceDueAmount;
     /**
      * 更新 stateAmount 为当前剩余未支付金额
+     *
+     * 优化版本：批量获取数据，避免重复查询数据库
      */
     private updateStateAmountToRemaining;
+    /**
+     * 检查订单支付是否完成（优化版，复用已获取的数据）
+     *
+     * @param paymentItems 已获取的支付项数据
+     * @param remainingAmount 已计算的剩余金额
+     */
+    private checkOrderPaymentCompletionOptimized;
     /**
      * 检查订单支付是否完成
      *
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 中会使用优化版本。
      */
     private checkOrderPaymentCompletion;
     /**
@@ -377,6 +424,8 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 重置 store 状态
      *
      * 在创建新订单前调用，确保状态完全干净
+     *
+     * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
      */
-    private resetStoreStateAsync;
+    private resetStoreState;
 }