@pisell/pisellos 0.0.254 → 0.0.256

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

@@ -17,6 +17,23 @@ export declare class DateModule extends BaseModule implements Module, DateModule
     getDateList(): ITime[];
     setDateList(dateList: ITime[]): void;
     fetchResourceDates(params: IGetAvailableTimeListParams): Promise<any>;
+    /**
+     * 将时间向上取整到下一个10分钟整数
+     *
+     * @param time dayjs 时间对象
+     * @returns 向上取整后的时间字符串 (YYYY-MM-DD HH:mm 格式)
+     */
+    private roundUpToNext10Minutes;
+    /**
+     * 校正资源时间段数据
+     *
+     * 如果时间段的 start_at 早于资源的 start_time，将其同步为 start_time 的下一个10分钟整数
+     * 如果修正后 end_at 也早于修正后的 start_time，则删除该时间段
+     *
+     * @param resourcesData 资源数据数组
+     * @returns 校正后的资源数据数组
+     */
+    private correctResourceTimeSlots;
     getResourceAvailableTimeList(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     clearDateRange(): void;
     storeChange(): void;

package/lib/modules/Date/index.js

@@ -32,6 +32,7 @@ __export(Date_exports, {
   DateModule: () => DateModule
 });
 module.exports = __toCommonJS(Date_exports);
+var import_dayjs = __toESM(require("dayjs"));
 var import_BaseModule = require("../BaseModule");
 var import_utils = require("./utils");
 var import_cloneDeep = __toESM(require("lodash-es/cloneDeep"));
@@ -138,11 +139,74 @@ var DateModule = class extends import_BaseModule.BaseModule {
       }, {
         useCache
       });
+      if ((res == null ? void 0 : res.data) && Array.isArray(res.data)) {
+        res.data = this.correctResourceTimeSlots(res.data);
+      }
       return res;
     } catch (error) {
       console.error(error);
     }
   }
+  /**
+   * 将时间向上取整到下一个10分钟整数
+   * 
+   * @param time dayjs 时间对象
+   * @returns 向上取整后的时间字符串 (YYYY-MM-DD HH:mm 格式)
+   */
+  roundUpToNext10Minutes(time) {
+    const minutes = time.minute();
+    const remainder = minutes % 10;
+    if (remainder === 0) {
+      return time.format("YYYY-MM-DD HH:mm");
+    } else {
+      const minutesToAdd = 10 - remainder;
+      const roundedTime = time.add(minutesToAdd, "minute");
+      return roundedTime.format("YYYY-MM-DD HH:mm");
+    }
+  }
+  /**
+   * 校正资源时间段数据
+   * 
+   * 如果时间段的 start_at 早于资源的 start_time，将其同步为 start_time 的下一个10分钟整数
+   * 如果修正后 end_at 也早于修正后的 start_time，则删除该时间段
+   * 
+   * @param resourcesData 资源数据数组
+   * @returns 校正后的资源数据数组
+   */
+  correctResourceTimeSlots(resourcesData) {
+    return resourcesData.map((resource) => {
+      if (!resource.times || !Array.isArray(resource.times) || !resource.start_time) {
+        return resource;
+      }
+      const resourceStartTime = (0, import_dayjs.default)(resource.start_time);
+      const correctedTimes = resource.times.map((timeSlot) => {
+        if (!timeSlot.start_at || !timeSlot.end_at) {
+          return timeSlot;
+        }
+        const startAt = (0, import_dayjs.default)(timeSlot.start_at);
+        const endAt = (0, import_dayjs.default)(timeSlot.end_at);
+        if (startAt.isBefore(resourceStartTime)) {
+          const roundedStartTime = this.roundUpToNext10Minutes(resourceStartTime);
+          const roundedStartTimeDayjs = (0, import_dayjs.default)(roundedStartTime);
+          console.log(`[DateModule] 修正时间段开始时间: ${timeSlot.start_at} -> ${roundedStartTime} (资源ID: ${resource.id}, 原始start_time: ${resource.start_time})`);
+          const correctedTimeSlot = {
+            ...timeSlot,
+            start_at: roundedStartTime
+          };
+          if (endAt.isBefore(roundedStartTimeDayjs)) {
+            console.log(`[DateModule] 时间段无效，将被删除: ${timeSlot.start_at} - ${timeSlot.end_at} (资源ID: ${resource.id}, 修正后start_time: ${roundedStartTime})`);
+            return null;
+          }
+          return correctedTimeSlot;
+        }
+        return timeSlot;
+      }).filter((timeSlot) => timeSlot !== null);
+      return {
+        ...resource,
+        times: correctedTimes
+      };
+    });
+  }
   async getResourceAvailableTimeList(params) {
     var _a;
     const { query, rules, type } = params;

package/lib/modules/Order/index.js

@@ -47,7 +47,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.core = core;
     this.store = options.store;
     this.request = this.core.getPlugin("request");
-    this.logger = this.core.getPlugin("logger");
+    const appPlugin = this.core.getPlugin("app");
+    if (!appPlugin) {
+      throw new Error("Order 模块需要 app 插件支持");
+    }
+    const app = appPlugin.getApp();
+    this.logger = app.logger;
     this.logInfo("OrderModule initialized successfully");
   }
   /**

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

@@ -31,19 +31,19 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
     /**
      * 记录信息日志
      */
-    private logInfo;
+    logInfo(title: string, metadata?: any): void;
     /**
      * 记录警告日志
      */
-    private logWarning;
+    logWarning(title: string, metadata?: any): void;
     /**
      * 记录错误日志
      */
-    private logError;
+    logError(title: string, error?: any, metadata?: any): void;
     /**
      * 记录调试日志
      */
-    private logDebug;
+    logDebug(title: string, metadata?: any): void;
     /**
      * 网络恢复以后，尝试执行队列
      *

package/lib/modules/Payment/index.js

@@ -504,7 +504,7 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
    * 为某个订单添加支付项（新方法）
    */
   async addPaymentItemAsync(orderUuid, paymentItem) {
-    var _a;
+    var _a, _b, _c;
     this.logInfo("Starting addPaymentItemAsync", {
       orderUuid,
       paymentAmount: paymentItem.amount,
@@ -532,6 +532,8 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         order_payment_type: paymentItem.order_payment_type || "normal",
         // 默认为正常支付
         metadata: {
+          ...paymentItem.metadata,
+          // 保留传入的所有 metadata 字段
           unique_payment_number: paymentUuid
           // 设置唯一支付号为支付项的 uuid
         }
@@ -547,7 +549,14 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
         orderUuid,
         paymentUuid: newPaymentItem.uuid,
         uniquePaymentNumber: (_a = newPaymentItem.metadata) == null ? void 0 : _a.unique_payment_number,
-        newExpectAmount: order.expect_amount
+        newExpectAmount: order.expect_amount,
+        paymentAmount: newPaymentItem.amount,
+        paymentCode: newPaymentItem.code,
+        orderPaymentType: newPaymentItem.order_payment_type,
+        metadataFields: Object.keys(newPaymentItem.metadata || {}),
+        // 现金支付找零信息
+        actualPaidAmount: (_b = newPaymentItem.metadata) == null ? void 0 : _b.actual_paid_amount,
+        changeGivenAmount: (_c = newPaymentItem.metadata) == null ? void 0 : _c.change_given_amount
       });
     } catch (error) {
       console.error("[PaymentModule] 添加支付项失败", error);

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

@@ -111,6 +111,10 @@ export interface PaymentItem {
         unique_payment_number?: string;
         /** rouding规则 */
         rounding_rule?: any;
+        /** 实付金额（现金支付时的实际给出金额） */
+        actual_paid_amount?: number;
+        /** 找零金额（现金支付时的找零金额） */
+        change_given_amount?: number;
     };
     /** rouding金额 */
     rounding_amount?: string;
@@ -230,6 +234,10 @@ export interface PaymentItemInput {
         unique_payment_number?: string;
         /** rounding规则 */
         rounding_rule?: any;
+        /** 实付金额（现金支付时的实际给出金额） */
+        actual_paid_amount?: number;
+        /** 找零金额（现金支付时的找零金额） */
+        change_given_amount?: number;
     };
 }
 /**

package/lib/modules/Payment/walletpass.js

@@ -40,7 +40,7 @@ var WalletPassPaymentImpl = class {
     try {
       this.paymentModule.core.effects.emit(hook, data);
     } catch (error) {
-      console.error("[WalletPass] 发送事件失败:", hook, error);
+      this.paymentModule.logError("[WalletPass] 发送事件失败", error, { hook });
     }
   }
   /**
@@ -48,6 +48,7 @@ var WalletPassPaymentImpl = class {
    * 根据业务数据生成标准的钱包API参数，并存储在模块中
    */
   generateWalletParams(businessData) {
+    var _a;
     const { customer_id, amountInfo, products, order_wait_pay_amount } = businessData;
     const totalAmount = Number(amountInfo.totalAmount);
     const subTotal = Number(amountInfo.subTotal);
@@ -65,7 +66,13 @@ var WalletPassPaymentImpl = class {
       prepare_payments: []
     };
     this.walletParams = walletParams;
-    console.log("[WalletPass] 钱包默认参数已生成并存储:", walletParams);
+    this.paymentModule.logInfo("[WalletPass] 钱包默认参数已生成并存储", {
+      customer_id: walletParams.customer_id,
+      order_expect_amount: walletParams.order_expect_amount,
+      order_product_amount: walletParams.order_product_amount,
+      order_wait_pay_amount: walletParams.order_wait_pay_amount,
+      products_count: ((_a = walletParams.products) == null ? void 0 : _a.length) || 0
+    });
     return walletParams;
   }
   /**
@@ -81,14 +88,14 @@ var WalletPassPaymentImpl = class {
    */
   clearStoredWalletParams() {
     this.walletParams = null;
-    console.log("[WalletPass] 已存储的钱包参数已清理");
+    this.paymentModule.logInfo("[WalletPass] 已存储的钱包参数已清理");
   }
   /**
    * 从业务数据初始化钱包数据
    * 内部生成参数，然后调用标准的初始化流程
    */
   async initializeWalletDataFromBusinessAsync(businessData) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const startTime = Date.now();
     const walletParams = this.generateWalletParams(businessData);
     if (Number(((_a = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _a.totalAmount) || 0) < 0 || Number(((_b = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _b.subTotal) || 0) < 0) {
@@ -101,6 +108,13 @@ var WalletPassPaymentImpl = class {
       businessData,
       startTime
     });
+    this.paymentModule.logInfo("[WalletPass] 开始从业务数据初始化钱包数据", {
+      customer_id: businessData.customer_id,
+      totalAmount: (_c = businessData.amountInfo) == null ? void 0 : _c.totalAmount,
+      subTotal: (_d = businessData.amountInfo) == null ? void 0 : _d.subTotal,
+      order_wait_pay_amount: businessData.order_wait_pay_amount,
+      products_count: ((_e = businessData.products) == null ? void 0 : _e.length) || 0
+    });
     try {
       const result = await this.initializeWalletDataAsync(walletParams);
       const endTime = Date.now();
@@ -112,7 +126,11 @@ var WalletPassPaymentImpl = class {
         endTime,
         duration
       });
-      console.log(`[WalletPass] 从业务数据初始化钱包数据成功，耗时: ${duration}ms`);
+      this.paymentModule.logInfo(`[WalletPass] 从业务数据初始化钱包数据成功`, {
+        duration: `${duration}ms`,
+        walletRecommendList_count: ((_f = result.walletRecommendList) == null ? void 0 : _f.length) || 0,
+        userIdentificationCodes_count: ((_g = result.userIdentificationCodes) == null ? void 0 : _g.length) || 0
+      });
       return result;
     } catch (error) {
       const endTime = Date.now();
@@ -124,7 +142,11 @@ var WalletPassPaymentImpl = class {
         endTime,
         duration
       });
-      console.error(`[WalletPass] 从业务数据初始化钱包数据失败，耗时: ${duration}ms`, error);
+      this.paymentModule.logError(`[WalletPass] 从业务数据初始化钱包数据失败`, error, {
+        duration: `${duration}ms`,
+        customer_id: businessData.customer_id,
+        totalAmount: (_h = businessData.amountInfo) == null ? void 0 : _h.totalAmount
+      });
       throw error;
     }
   }
@@ -148,12 +170,20 @@ var WalletPassPaymentImpl = class {
         userIdentificationCodes
       };
     } catch (error) {
-      console.error("[WalletPass] 初始化钱包数据失败:", error);
+      this.paymentModule.logError("[WalletPass] 初始化钱包数据失败", error, {
+        customer_id: baseParams.customer_id,
+        order_expect_amount: baseParams.order_expect_amount
+      });
       throw error;
     }
   }
   async getWalletPassRecommendListAsync(params) {
     try {
+      this.paymentModule.logInfo("[WalletPass] 开始获取钱包推荐列表", {
+        customer_id: params.customer_id,
+        order_expect_amount: params.order_expect_amount,
+        sale_channel: params.sale_channel
+      });
       const response = await this.paymentModule.request.post(
         "/machinecode/prepare/deduction/recommend",
         params
@@ -163,14 +193,22 @@ var WalletPassPaymentImpl = class {
       this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListUpdated, {
         walletRecommendList: this.walletRecommendList
       });
-      console.log(
-        "[WalletPass] 钱包推荐列表已更新:",
-        this.walletRecommendList.length,
-        "项"
-      );
+      this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已更新", {
+        count: this.walletRecommendList.length,
+        items: this.walletRecommendList.map((item) => ({
+          voucher_id: item.voucher_id,
+          name: item.name,
+          amount: item.amount,
+          tag: item.tag
+        }))
+      });
       return this.walletRecommendList;
     } catch (error) {
-      console.error("获取钱包推荐列表失败:", error);
+      this.paymentModule.logError("[WalletPass] 获取钱包推荐列表失败", error, {
+        customer_id: params.customer_id,
+        order_expect_amount: params.order_expect_amount,
+        sale_channel: params.sale_channel
+      });
       return [];
     }
   }
@@ -178,11 +216,18 @@ var WalletPassPaymentImpl = class {
     return (0, import_utils.formatWalletPassList2PreparePayments)(list);
   }
   async getUserIdentificationCodeListAsync(params) {
+    var _a;
     try {
       const newParams = {
         ...this.walletParams,
         ...params
       };
+      this.paymentModule.logInfo("[WalletPass] 开始获取用户识别码列表", {
+        customer_id: newParams.customer_id,
+        available: newParams.available,
+        prepare_payments_count: ((_a = newParams.prepare_payments) == null ? void 0 : _a.length) || 0,
+        filter_prepare_wallet_pass: newParams.filter_prepare_wallet_pass
+      });
       const response = await this.paymentModule.request.post(
         "/machinecode/prepare/deduction",
         newParams
@@ -192,14 +237,20 @@ var WalletPassPaymentImpl = class {
       this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
         userIdentificationCodes: this.userIdentificationCodes
       });
-      console.log(
-        "[WalletPass] 用户识别码列表已更新:",
-        this.userIdentificationCodes.length,
-        "项"
-      );
+      this.paymentModule.logInfo("[WalletPass] 用户识别码列表已更新", {
+        count: this.userIdentificationCodes.length,
+        sorted_items: this.userIdentificationCodes.slice(0, 5).map((item) => ({
+          code: item.code,
+          error_code: item.error_code,
+          error_msg: item.error_msg
+        }))
+      });
       return this.userIdentificationCodes;
     } catch (error) {
-      console.error("获取用户识别码列表失败:", error);
+      this.paymentModule.logError("[WalletPass] 获取用户识别码列表失败", error, {
+        customer_id: params.customer_id,
+        available: params.available
+      });
       return [];
     }
   }
@@ -212,6 +263,11 @@ var WalletPassPaymentImpl = class {
   async searchIdentificationCodeAsync(params, config = {}) {
     try {
       const { code } = params;
+      this.paymentModule.logInfo("[WalletPass] 开始搜索识别码", {
+        code,
+        code_length: code.length,
+        noCache: config.noCache || false
+      });
       const isWalletCode = code.startsWith("WL");
       if (isWalletCode) {
         const walletDetailParams = {
@@ -219,11 +275,21 @@ var WalletPassPaymentImpl = class {
           with_customer: 1,
           with: ["wallet"]
         };
+        this.paymentModule.logInfo("[WalletPass] 搜索钱包识别码", {
+          code,
+          with_customer: walletDetailParams.with_customer,
+          with: walletDetailParams.with
+        });
         const response2 = await this.paymentModule.request.post(
           "/wallet/detail/search",
           walletDetailParams
         );
         const searchResults2 = (response2 == null ? void 0 : response2.data) || [];
+        this.paymentModule.logInfo("[WalletPass] 钱包识别码搜索完成", {
+          code,
+          results_count: searchResults2.length,
+          type: "walletCode"
+        });
         return {
           type: "walletCode",
           data: searchResults2
@@ -244,6 +310,12 @@ var WalletPassPaymentImpl = class {
         // 搜索特有参数
         code: params.code
       };
+      this.paymentModule.logInfo("[WalletPass] 搜索普通识别码", {
+        code: searchParams.code,
+        customer_id: searchParams.customer_id,
+        order_expect_amount: searchParams.order_expect_amount,
+        multiple: searchParams.multiple
+      });
       const response = await this.paymentModule.request.post(
         "/machinecode/prepare/deduction/search",
         searchParams
@@ -270,18 +342,38 @@ var WalletPassPaymentImpl = class {
         cachedSearchResults: [...this.searchResults],
         searchParams: params
       });
+      this.paymentModule.logInfo("[WalletPass] 普通识别码搜索完成", {
+        code: params.code,
+        results_count: searchResults.length,
+        cached_results_count: this.searchResults.length,
+        type: "normalCode"
+      });
       return {
         type: "normalCode",
         data: searchResults
       };
     } catch (error) {
-      console.error("[WalletPass] 搜索识别码信息失败:", error);
+      this.paymentModule.logError("[WalletPass] 搜索识别码信息失败", error, {
+        code: params.code,
+        customer_id: params.customer_id,
+        order_expect_amount: params.order_expect_amount
+      });
       throw error;
     }
   }
   async processWalletPayment(amount, orderUuid, voucherId) {
+    this.paymentModule.logInfo("[WalletPass] 开始处理钱包支付", {
+      amount,
+      orderUuid,
+      voucherId: voucherId || "none"
+    });
     const walletMethod = await this.paymentModule.getWalletPaymentMethod();
     if (!walletMethod) {
+      this.paymentModule.logError("[WalletPass] 钱包支付方式未找到", null, {
+        amount,
+        orderUuid,
+        voucherId
+      });
       throw new Error("钱包支付方式未找到");
     }
     const paymentItem = {
@@ -293,6 +385,12 @@ var WalletPassPaymentImpl = class {
       voucher_id: voucherId || ""
     };
     await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
+    this.paymentModule.logInfo("[WalletPass] 钱包支付处理完成", {
+      amount,
+      orderUuid,
+      voucherId: voucherId || "none",
+      payment_method: walletMethod.name
+    });
   }
   async getWalletBalance(voucherId) {
     return 0;
@@ -317,7 +415,7 @@ var WalletPassPaymentImpl = class {
     this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListCleared, {
       clearedTypes: ["walletRecommendList"]
     });
-    console.log("[WalletPass] 钱包推荐列表已清除");
+    this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已清除");
   }
   /**
    * 清除用户识别码列表
@@ -327,7 +425,7 @@ var WalletPassPaymentImpl = class {
     this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesCleared, {
       clearedTypes: ["userIdentificationCodes"]
     });
-    console.log("[WalletPass] 用户识别码列表已清除");
+    this.paymentModule.logInfo("[WalletPass] 用户识别码列表已清除");
   }
   /**
    * 获取缓存的搜索结果列表
@@ -346,7 +444,7 @@ var WalletPassPaymentImpl = class {
    */
   clearSearchResults() {
     this.searchResults = [];
-    console.log("[WalletPass] 搜索结果缓存已清除");
+    this.paymentModule.logInfo("[WalletPass] 搜索结果缓存已清除");
   }
   /**
    * 清除所有缓存数据
@@ -359,7 +457,9 @@ var WalletPassPaymentImpl = class {
     this.emitEvent(import_types.WalletPassHooks.OnWalletCacheCleared, {
       clearedTypes: ["all"]
     });
-    console.log("[WalletPass] 所有缓存数据已清除（包括钱包参数和搜索结果）");
+    this.paymentModule.logInfo("[WalletPass] 所有缓存数据已清除", {
+      cleared_types: ["walletRecommendList", "userIdentificationCodes", "searchResults", "walletParams"]
+    });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -379,6 +379,21 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 验证结账参数
      */
     private validateCheckoutParams;
+    /**
+     * 处理现金支付项的找零逻辑
+     *
+     * @param paymentItem 原始支付项
+     * @returns 处理后的支付项（包含找零信息）
+     */
+    private processCashPaymentItem;
+    /**
+     * 判断是否为现金支付
+     *
+     * @param paymentCode 支付代码
+     * @param paymentType 支付类型
+     * @returns 是否为现金支付
+     */
+    private isCashPayment;
     /**
      * 预加载支付方式（在初始化时调用）
      */