@pisell/pisellos 2.1.28 → 2.1.30

package/dist/modules/Payment/index.js

@@ -131,6 +131,10 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
               return this.ensurePaymentTables();
             case 14:
               this.registerNetworkHandlers();
+
+              // // 预连接数据库
+              // this.dbManager.connect()
+
               console.log('[PaymentModule] 初始化完成');
               this.logInfo('PaymentModule initialized successfully');
             case 17:
@@ -657,7 +661,8 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
     key: "createPaymentOrderAsync",
     value: (function () {
       var _createPaymentOrderAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(params) {
-        var existingOrder, newOrder;
+        var _this3 = this;
+        var newOrder, dbAddStartTime, dbAddDuration;
         return _regeneratorRuntime().wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -666,41 +671,41 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 totalAmount: params.total_amount
               });
               _context7.prev = 1;
-              _context7.next = 4;
-              return this.dbManager.get('order', params.order_id);
-            case 4:
-              existingOrder = _context7.sent;
-              this.logInfo('createPaymentOrderAsync existingOrder', {
-                existingOrder: existingOrder
-              });
+              // 检测是否有重复的 order_id
+              // console.time('createLocalOrderAsync: getExistingOrder')
+              // const existingOrder = await this.dbManager.get('order', params.order_id);
+              // const existingOrders = await this.dbManager.getAll('order');
               // const existingOrder = existingOrders.find(
               //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
               // );
-              if (!existingOrder) {
-                _context7.next = 20;
-                break;
-              }
-              // 如果存在相同 order_id 的订单，更新该订单信息
-              this.logInfo("createPaymentOrderAsync found duplicate order ID: ".concat(params.order_id, ", updating existing payment order"));
-
-              // const originalOrder = { ...existingOrder };
-              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);
-
-              // 更新到数据库
-              _context7.next = 15;
-              return this.dbManager.update('order', existingOrder);
-            case 15:
-              _context7.next = 17;
-              return this.core.effects.emit(PaymentHooks.OnOrderUpdated, existingOrder);
-            case 17:
-              return _context7.abrupt("return", existingOrder);
-            case 20:
+              // this.logInfo('createPaymentOrderAsync existingOrder', {
+              //   existingOrder
+              // });
+              // console.timeEnd('createLocalOrderAsync: getExistingOrder')
+              // const existingOrder = existingOrders.find(
+              //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
+              // );
+              // if (existingOrder) {
+              //   // 如果存在相同 order_id 的订单，更新该订单信息
+              //   this.logInfo(
+              //     `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`,
+              //   );
+              //   // const originalOrder = { ...existingOrder };
+              //   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);
+              //   // 触发更新事件
+              //   this.core.effects.emit(
+              //     `${this.name}:onOrderUpdated`,
+              //     existingOrder,
+              //   );
+              //   return existingOrder;
+              // } else {
               // 创建新的支付订单
               newOrder = {
                 uuid: getUniqueId('pay_order_'),
@@ -715,32 +720,37 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 tax_fee: '0.00',
                 is_deposit: params.is_deposit || 0,
                 deposit_amount: params.deposit_amount || '0.00'
-              };
-              _context7.next = 23;
+              }; // 🚀 性能监控：记录数据库添加操作耗时
+              dbAddStartTime = Date.now();
+              _context7.next = 6;
               return this.dbManager.add('order', newOrder);
-            case 23:
-              this.core.effects.emit(PaymentHooks.OnOrderAdded, newOrder);
-              this.logInfo('createPaymentOrderAsync completed - new payment order created', {
+            case 6:
+              dbAddDuration = Date.now() - dbAddStartTime;
+              this.logInfo('Database add operation completed', {
+                operation: 'dbManager.add',
+                table: 'order',
                 orderUuid: newOrder.uuid,
-                orderId: newOrder.id
+                orderId: newOrder.order_id,
+                duration: "".concat(dbAddDuration, "ms"),
+                performance: dbAddDuration > 100 ? 'slow' : dbAddDuration > 50 ? 'medium' : 'fast'
               });
+              setTimeout(function () {
+                _this3.core.effects.emit("".concat(_this3.name, ":onOrderAdded"), newOrder);
+              }, 0);
               return _context7.abrupt("return", newOrder);
-            case 26:
-              _context7.next = 33;
-              break;
-            case 28:
-              _context7.prev = 28;
+            case 12:
+              _context7.prev = 12;
               _context7.t0 = _context7["catch"](1);
               console.error('[PaymentModule] 创建支付订单失败', _context7.t0);
               this.logError('createPaymentOrderAsync failed', _context7.t0, {
                 orderId: params.order_id
               });
               throw _context7.t0;
-            case 33:
+            case 17:
             case "end":
               return _context7.stop();
           }
-        }, _callee7, this, [[1, 28]]);
+        }, _callee7, this, [[1, 12]]);
       }));
       function createPaymentOrderAsync(_x6) {
         return _createPaymentOrderAsync.apply(this, arguments);
@@ -1808,7 +1818,7 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
           // 例如：amount=15, rounding_amount=-0.2，有效支付=15.2（抹掉0.2元零头）
           var paymentAmount = new Decimal(payment.amount || 0);
           var roundingAmount = new Decimal(payment.rounding_amount || 0);
-          var effectiveAmount = paymentAmount.plus(roundingAmount.abs());
+          var effectiveAmount = paymentAmount.plus(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
           return sum.plus(effectiveAmount);
         } catch (error) {
           console.warn("[PaymentModule] \u65E0\u6548\u7684\u652F\u4ED8\u91D1\u989D: amount=".concat(payment.amount, ", rounding_amount=").concat(payment.rounding_amount, "\uFF0C\u8DF3\u8FC7\u8BA1\u7B97"));
@@ -1836,7 +1846,7 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
             code: p.code,
             amount: p.amount,
             rounding_amount: p.rounding_amount || '0.00',
-            effective_amount: new Decimal(p.amount || 0).plus(new Decimal(p.rounding_amount || 0).abs()).toFixed(2)
+            effective_amount: new Decimal(p.amount || 0).plus(new Decimal(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || 0).abs()).toFixed(2)
           };
         }),
         说明: '有效支付金额包含抹零计算（amount + |rounding_amount|）'

package/dist/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;
 }