@pisell/pisellos 0.0.195 → 0.0.199

package/dist/modules/Payment/types.d.ts

@@ -292,6 +292,8 @@ export interface PaymentModuleAPI {
     getPartiallyPaidOrdersAsync: () => Promise<PaymentOrder[]>;
     /** 获取未同步到服务器的订单 */
     getUnsyncedOrdersAsync: () => Promise<PaymentOrder[]>;
+    /** 检测未同步的订单并重新加入任务队列 */
+    recheckAndRequeueUnsyncedOrders: () => Promise<number>;
     /** 手动执行支付同步队列 */
     runPaymentSyncQueue: () => Promise<void>;
 }

package/dist/modules/Rules/index.js

@@ -317,7 +317,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
       // 然后再处理应用哪些优惠券，此时只考虑filteredDiscountList中的优惠券
       sortedProductList.forEach(function (originProduct, i) {
-        var _product$discount_lis4, _product$discount_lis5, _product$discount_lis6, _product$discount_lis7, _product$discount_lis8, _product$discount_lis9;
+        var _product$discount_lis4, _product$discount_lis5, _product$discount_lis7, _product$discount_lis8, _product$discount_lis9, _product$discount_lis10;
         var product = _this3.hooks.getProduct(originProduct);
         if (product !== null && product !== void 0 && product.booking_id && (_product$discount_lis4 = product.discount_list) !== null && _product$discount_lis4 !== void 0 && _product$discount_lis4.length && product !== null && product !== void 0 && (_product$discount_lis5 = product.discount_list) !== null && _product$discount_lis5 !== void 0 && _product$discount_lis5.every(function (discount) {
           return discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type);
@@ -328,11 +328,15 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
         // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
         var applicableDiscounts = sortedDiscountList.filter(function (discount) {
+          var _product$discount_lis6;
           // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
           // 商品券时主商品价格为0不可用
           if ((Number(product.price) === 0 || !product.price) && (discount.tag || discount.type) === 'good_pass') return false;
           // 折扣卡时总价为0时不可用
-          if ((Number(product.total) === 0 || !product.total) && (discount.tag || discount.type) !== 'good_pass') return false;
+          if ((Number(product.total) === 0 || !product.total) && !((_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.find(function (n) {
+            var _n$discount;
+            return ((_n$discount = n.discount) === null || _n$discount === void 0 ? void 0 : _n$discount.resource_id) === discount.id;
+          })) && (discount.tag || discount.type) !== 'good_pass') return false;
           // 如果优惠券已被使用，则跳过
           var targetUsedDiscounts = usedDiscounts.get(discount.id);
           if (targetUsedDiscounts && (discount.tag || discount.type) === 'good_pass') return false;
@@ -356,12 +360,12 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         var selectedDiscount = selectedDiscountCard || applicableDiscounts[0];
 
         // 如果是手动折扣，则不适用优惠券
-        var isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.total != product.origin_total && (!((_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.length) || (product === null || product === void 0 || (_product$discount_lis7 = product.discount_list) === null || _product$discount_lis7 === void 0 || (_product$discount_lis8 = _product$discount_lis7.every) === null || _product$discount_lis8 === void 0 ? void 0 : _product$discount_lis8.call(_product$discount_lis7, function (item) {
+        var isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.total != product.origin_total && (!((_product$discount_lis7 = product.discount_list) !== null && _product$discount_lis7 !== void 0 && _product$discount_lis7.length) || (product === null || product === void 0 || (_product$discount_lis8 = product.discount_list) === null || _product$discount_lis8 === void 0 || (_product$discount_lis9 = _product$discount_lis8.every) === null || _product$discount_lis9 === void 0 ? void 0 : _product$discount_lis9.call(_product$discount_lis8, function (item) {
           return item.type === 'product';
         })));
 
         // 勾选时覆盖手动折扣
-        if (options !== null && options !== void 0 && options.discountId && (_product$discount_lis9 = product.discount_list) !== null && _product$discount_lis9 !== void 0 && _product$discount_lis9.some(function (item) {
+        if (options !== null && options !== void 0 && options.discountId && (_product$discount_lis10 = product.discount_list) !== null && _product$discount_lis10 !== void 0 && _product$discount_lis10.some(function (item) {
           var _item$discount;
           return ((_item$discount = item.discount) === null || _item$discount === void 0 ? void 0 : _item$discount.resource_id) === options.discountId;
         })) {
@@ -423,7 +427,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           }));
         }
         for (var _i = 0; _i < splitCount; _i++) {
-          var _originProduct$_produ, _product$discount_lis10;
+          var _originProduct$_produ, _product$discount_lis11;
           // 如果用过折扣卡，也就不存在拆分的情况了，这里直接使用上面计算出来的折扣卡
           var _selectedDiscount = selectedDiscountCard || applicableDiscounts[_i];
           // 标记优惠券为已使用
@@ -439,7 +443,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
             productOriginTotal = product.total;
           }
           // 如果当前 product 有 discount_list，则必须从 origin_total 拿
-          if ((_product$discount_lis10 = product.discount_list) !== null && _product$discount_lis10 !== void 0 && _product$discount_lis10.length && product.origin_total) {
+          if ((_product$discount_lis11 = product.discount_list) !== null && _product$discount_lis11 !== void 0 && _product$discount_lis11.length && product.origin_total) {
             productOriginTotal = product.origin_total;
           }
 

package/lib/modules/Payment/index.d.ts

@@ -181,9 +181,47 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
      * 注意：只清理完全支付的订单，部分支付的订单保留以便继续支付
      */
     cleanupFinishedOrders(): Promise<void>;
+    /**
+     * 检测未同步的订单并重新加入任务队列
+     *
+     * 此方法专门用于处理因网络问题导致任务队列执行失败但队列被清空的情况。
+     * 它会检查本地 IndexDB 中所有未同步的订单（isSynced: false），
+     * 并将这些订单重新添加到任务队列中。
+     *
+     * 使用场景：
+     * - 网络恢复后重新检查未同步的订单
+     * - 应用启动时检查并重新排队未完成的支付
+     * - 用户手动重试前的预检查
+     *
+     * @returns Promise<number> 返回重新加入队列的订单数量
+     */
+    recheckAndRequeueUnsyncedOrders(): Promise<number>;
     /**
      * 手动执行支付同步队列
      * 外部可以调用此方法来触发支付同步任务的执行
+     *
+     * 注意：此方法只执行现有队列中的任务，不会检查未同步的订单。
+     * 如果需要检查未同步订单，请先调用 recheckAndRequeueUnsyncedOrders()
+     *
+     * 使用示例：
+     * ```typescript
+     * // 1. 先检查并重新排队未同步订单，然后执行队列
+     * const requeuedCount = await paymentModule.recheckAndRequeueUnsyncedOrders();
+     * if (requeuedCount > 0) {
+     *   await paymentModule.runPaymentSyncQueue();
+     * }
+     *
+     * // 2. 或者直接执行现有队列（不检查未同步订单）
+     * await paymentModule.runPaymentSyncQueue();
+     * ```
      */
     runPaymentSyncQueue(): Promise<void>;
+    /**
+     * 重新将订单添加到同步队列
+     * 用于处理因网络问题导致任务队列清空但订单未同步的情况
+     *
+     * @param order 要重新添加的订单
+     * @returns Promise<boolean> 是否成功添加到队列
+     */
+    private reAddOrderToSyncQueue;
 }

package/lib/modules/Payment/index.js

@@ -145,7 +145,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
   registerNetworkHandlers() {
     const network = this.app.plugins.get("network");
     this.logInfo("Registering network status listener");
-    network == null ? void 0 : network.addListener("networkStatusChange", (status) => {
+    network == null ? void 0 : network.addListener("networkStatusChange", async (status) => {
       console.log("网络状态:", status.connected);
       this.logInfo("Network status changed", {
         connected: status.connected,
@@ -153,7 +153,10 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       });
       if (status.connected) {
         this.logInfo("Network reconnected - triggering payment sync queue");
-        this.runPaymentSyncQueue();
+        const requeuedCount = await this.recheckAndRequeueUnsyncedOrders();
+        if (requeuedCount > 0) {
+          await this.runPaymentSyncQueue();
+        }
       }
     });
   }
@@ -979,12 +982,86 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       console.error("[PaymentModule] 清理已完成订单失败", error);
     }
   }
+  /**
+   * 检测未同步的订单并重新加入任务队列
+   *
+   * 此方法专门用于处理因网络问题导致任务队列执行失败但队列被清空的情况。
+   * 它会检查本地 IndexDB 中所有未同步的订单（isSynced: false），
+   * 并将这些订单重新添加到任务队列中。
+   *
+   * 使用场景：
+   * - 网络恢复后重新检查未同步的订单
+   * - 应用启动时检查并重新排队未完成的支付
+   * - 用户手动重试前的预检查
+   *
+   * @returns Promise<number> 返回重新加入队列的订单数量
+   */
+  async recheckAndRequeueUnsyncedOrders() {
+    this.logInfo("Starting recheckAndRequeueUnsyncedOrders");
+    try {
+      if (!this.app.tasksManager) {
+        console.warn(
+          "[PaymentModule] TasksManager 未初始化，无法重新排队未同步订单"
+        );
+        this.logWarning(
+          "TasksManager not initialized, cannot requeue unsynced orders"
+        );
+        return 0;
+      }
+      const unsyncedOrders = await this.getUnsyncedOrdersAsync();
+      if (unsyncedOrders.length === 0) {
+        console.log("[PaymentModule] 没有发现未同步的订单");
+        this.logInfo("No unsynced orders found");
+        return 0;
+      }
+      console.log(
+        `[PaymentModule] 发现 ${unsyncedOrders.length} 个未同步的订单，开始重新加入任务队列`
+      );
+      this.logInfo("Found unsynced orders, adding to sync queue", {
+        unsyncedCount: unsyncedOrders.length,
+        orderUuids: unsyncedOrders.map((o) => o.uuid)
+      });
+      let requeuedCount = 0;
+      for (const order of unsyncedOrders) {
+        const success = await this.reAddOrderToSyncQueue(order);
+        if (success) {
+          requeuedCount++;
+        }
+      }
+      console.log(
+        `[PaymentModule] 成功重新加入 ${requeuedCount} 个订单到任务队列`
+      );
+      this.logInfo("Successfully requeued unsynced orders", {
+        requeuedCount,
+        totalFound: unsyncedOrders.length
+      });
+      return requeuedCount;
+    } catch (error) {
+      console.error("[PaymentModule] 重新排队未同步订单失败", error);
+      this.logError("recheckAndRequeueUnsyncedOrders failed", error);
+      return 0;
+    }
+  }
   /**
    * 手动执行支付同步队列
    * 外部可以调用此方法来触发支付同步任务的执行
+   *
+   * 注意：此方法只执行现有队列中的任务，不会检查未同步的订单。
+   * 如果需要检查未同步订单，请先调用 recheckAndRequeueUnsyncedOrders()
+   *
+   * 使用示例：
+   * ```typescript
+   * // 1. 先检查并重新排队未同步订单，然后执行队列
+   * const requeuedCount = await paymentModule.recheckAndRequeueUnsyncedOrders();
+   * if (requeuedCount > 0) {
+   *   await paymentModule.runPaymentSyncQueue();
+   * }
+   *
+   * // 2. 或者直接执行现有队列（不检查未同步订单）
+   * await paymentModule.runPaymentSyncQueue();
+   * ```
    */
   async runPaymentSyncQueue() {
-    var _a;
     this.logInfo("Starting runPaymentSyncQueue");
     try {
       if (!this.app.tasksManager) {
@@ -996,7 +1073,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         module: "payment",
         queueId: "payment_sync"
       });
-      if (!((_a = queue == null ? void 0 : queue.tasks) == null ? void 0 : _a.length)) {
+      if (!(queue == null ? void 0 : queue.length)) {
         console.log("[PaymentModule] 支付同步队列无内容，不执行");
         return;
       }
@@ -1021,6 +1098,52 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       this.logError("runPaymentSyncQueue failed", error);
     }
   }
+  /**
+   * 重新将订单添加到同步队列
+   * 用于处理因网络问题导致任务队列清空但订单未同步的情况
+   *
+   * @param order 要重新添加的订单
+   * @returns Promise<boolean> 是否成功添加到队列
+   */
+  async reAddOrderToSyncQueue(order) {
+    try {
+      const paymentData = {
+        payments: order.payment.map((payment) => payment),
+        payment_status: order.payment_status === import_types.PaymentStatus.Finished ? "paid" : "partially_paid"
+      };
+      const existingQueue = this.app.tasksManager.getTaskQueue({
+        module: "payment",
+        queueId: "payment_sync"
+      });
+      const taskId = `payment_${order.uuid}`;
+      const taskExists = existingQueue == null ? void 0 : existingQueue.some((task) => task.id === taskId);
+      if (taskExists) {
+        console.log(
+          `[PaymentModule] 任务 ${taskId} 已存在于队列中，跳过重复添加`
+        );
+        return false;
+      }
+      await this.addToSyncQueue(order, paymentData);
+      console.log(`[PaymentModule] 订单 ${order.uuid} 已重新添加到同步队列`);
+      this.logInfo("Order re-added to sync queue", {
+        orderUuid: order.uuid,
+        orderId: order.order_info.order_id,
+        paymentStatus: order.payment_status,
+        unsyncedPayments: order.payment.filter((p) => !p.isSynced).length
+      });
+      return true;
+    } catch (error) {
+      console.error(
+        `[PaymentModule] 重新添加订单 ${order.uuid} 到同步队列失败`,
+        error
+      );
+      this.logError("Failed to re-add order to sync queue", error, {
+        orderUuid: order.uuid,
+        orderId: order.order_info.order_id
+      });
+      return false;
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/modules/Payment/types.d.ts

@@ -292,6 +292,8 @@ export interface PaymentModuleAPI {
     getPartiallyPaidOrdersAsync: () => Promise<PaymentOrder[]>;
     /** 获取未同步到服务器的订单 */
     getUnsyncedOrdersAsync: () => Promise<PaymentOrder[]>;
+    /** 检测未同步的订单并重新加入任务队列 */
+    recheckAndRequeueUnsyncedOrders: () => Promise<number>;
     /** 手动执行支付同步队列 */
     runPaymentSyncQueue: () => Promise<void>;
 }

package/lib/modules/Rules/index.js

@@ -214,9 +214,13 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         return;
       }
       const applicableDiscounts = sortedDiscountList.filter((discount) => {
+        var _a2;
         if ((Number(product.price) === 0 || !product.price) && (discount.tag || discount.type) === "good_pass")
           return false;
-        if ((Number(product.total) === 0 || !product.total) && (discount.tag || discount.type) !== "good_pass")
+        if ((Number(product.total) === 0 || !product.total) && !((_a2 = product.discount_list) == null ? void 0 : _a2.find((n) => {
+          var _a3;
+          return ((_a3 = n.discount) == null ? void 0 : _a3.resource_id) === discount.id;
+        })) && (discount.tag || discount.type) !== "good_pass")
           return false;
         const targetUsedDiscounts = usedDiscounts.get(discount.id);
         if (targetUsedDiscounts && (discount.tag || discount.type) === "good_pass")

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "0.0.195",
+  "version": "0.0.199",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",