@pisell/pisellos 0.0.194 → 0.0.196

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/lib/modules/Payment/index.d.ts

@@ -2,6 +2,13 @@ import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
 import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPayment } from './types';
 export * from './types';
+export { generateRequestUniqueId };
+/**
+ * 生成请求唯一ID
+ * 格式: 年月日时分秒毫秒+4位随机数
+ * 示例: 20241201143025123456
+ */
+declare function generateRequestUniqueId(): string;
 /**
  * 支付模块实现
  *
@@ -174,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

@@ -20,7 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/modules/Payment/index.ts
 var Payment_exports = {};
 __export(Payment_exports, {
-  PaymentModule: () => PaymentModule
+  PaymentModule: () => PaymentModule,
+  generateRequestUniqueId: () => generateRequestUniqueId
 });
 module.exports = __toCommonJS(Payment_exports);
 var import_BaseModule = require("../BaseModule");
@@ -40,6 +41,18 @@ function formatAmount(amount) {
     return "0.00";
   }
 }
+function generateRequestUniqueId() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  const millisecond = String(now.getMilliseconds()).padStart(3, "0");
+  const randomDigits = Math.floor(Math.random() * 9e3) + 1e3;
+  return `${year}${month}${day}${hour}${minute}${second}${millisecond}${randomDigits}`;
+}
 var PaymentModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
@@ -130,9 +143,9 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    *
    */
   registerNetworkHandlers() {
-    const network = this.app.usePlugin("network");
+    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,
@@ -140,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();
+        }
       }
     });
   }
@@ -738,13 +754,18 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
     var _a, _b, _c, _d, _e, _f;
     const { orderUuid, orderId, paymentData, core } = payload.task.payload;
     console.log(`[PaymentModule] 开始后台同步支付，订单ID: ${orderId}`);
+    paymentData.request_unique = generateRequestUniqueId();
     const app = window.app;
     const logger = app == null ? void 0 : app.logger;
     if (logger) {
       logger.addLog({
         type: "info",
         title: "[PaymentModule] Starting syncPaymentTask",
-        metadata: { orderUuid, orderId, paymentDataKeys: Object.keys(paymentData) }
+        metadata: {
+          orderUuid,
+          orderId,
+          paymentDataKeys: Object.keys(paymentData)
+        }
       });
     }
     if (!app) {
@@ -878,7 +899,9 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
             payment.isSynced = true;
           });
           await dbManager.update("order", order);
-          console.log(`[PaymentModule] 订单 ${orderUuid} 业务错误，已标记为已同步`);
+          console.log(
+            `[PaymentModule] 订单 ${orderUuid} 业务错误，已标记为已同步`
+          );
         }
         return {
           status: "completed_with_error",
@@ -959,9 +982,84 @@ 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() {
     this.logInfo("Starting runPaymentSyncQueue");
@@ -971,6 +1069,14 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         this.logWarning("TasksManager not initialized, cannot run sync queue");
         return;
       }
+      const queue = this.app.tasksManager.getTaskQueue({
+        module: "payment",
+        queueId: "payment_sync"
+      });
+      if (!(queue == null ? void 0 : queue.length)) {
+        console.log("[PaymentModule] 支付同步队列无内容，不执行");
+        return;
+      }
       console.log("[PaymentModule] 开始执行支付同步队列");
       await this.app.tasksManager.run({
         module: "payment",
@@ -992,9 +1098,56 @@ 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 = {
   PaymentModule,
+  generateRequestUniqueId,
   ...require("./types")
 });

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/package.json

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