@pisell/pisellos 0.0.229 → 0.0.231

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

@@ -1,6 +1,6 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { OrderModuleAPI, CommitOrderParams } from './types';
+import { OrderModuleAPI, CommitOrderParams, CheckoutOrderParams } from './types';
 import { CartItem } from '../Cart/types';
 export declare class OrderModule extends BaseModule implements Module, OrderModuleAPI {
     protected defaultName: string;
@@ -11,7 +11,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     createOrder(params: CommitOrderParams['query']): {
         type: "virtual" | "appointment_booking";
-        platform: string;
+        platform: "pc" | "h5";
         sales_channel: string;
         order_sales_channel: string;
         bookings: any[];
@@ -26,4 +26,15 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
         type: 'holder' | 'account';
     }): boolean;
     submitOrder(order: CommitOrderParams): Promise<void>;
+    /**
+     * Checkout 专用：创建订单到后端
+     *
+     * 专门为 Checkout 模块设计的订单创建方法，
+     * 直接调用 /order/checkout 接口创建订单
+     * 接收已经处理好的订单数据，无需再处理购物车
+     *
+     * @param params Checkout 订单参数（已处理的订单数据）
+     * @returns 后端返回的订单数据（包含订单ID等）
+     */
+    createOrderByCheckout(params: CheckoutOrderParams): Promise<any>;
 }

package/lib/modules/Order/index.js

@@ -41,7 +41,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const order = {
       type: (params == null ? void 0 : params.type) || "appointment_booking",
       // 要从外面拿，virtual
-      platform: (params == null ? void 0 : params.platform) === "pc" ? "PC" : "H5",
+      platform: (params == null ? void 0 : params.platform) || "pc",
       sales_channel: "my_pisel",
       order_sales_channel: "online_store",
       bookings: [],
@@ -101,6 +101,63 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const params = this.createOrder(query);
     return this.request.post(fetchUrl, params);
   }
+  /**
+   * Checkout 专用：创建订单到后端
+   * 
+   * 专门为 Checkout 模块设计的订单创建方法，
+   * 直接调用 /order/checkout 接口创建订单
+   * 接收已经处理好的订单数据，无需再处理购物车
+   * 
+   * @param params Checkout 订单参数（已处理的订单数据）
+   * @returns 后端返回的订单数据（包含订单ID等）
+   */
+  async createOrderByCheckout(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    console.log("[Order] createOrderByCheckout 开始创建订单:", {
+      type: params.type,
+      platform: params.platform,
+      is_deposit: params.is_deposit,
+      customer_id: params.customer_id,
+      bookingsCount: ((_a = params.bookings) == null ? void 0 : _a.length) || 0,
+      relationProductsCount: ((_b = params.relation_products) == null ? void 0 : _b.length) || 0,
+      paymentsCount: ((_c = params.payments) == null ? void 0 : _c.length) || 0
+    });
+    try {
+      const orderData = {
+        sales_channel: "my_pisel",
+        order_sales_channel: "online_store",
+        shop_note: "",
+        schedule_date: "",
+        is_deposit: 0,
+        bookings: [],
+        relation_products: [],
+        relation_forms: [],
+        payments: [],
+        ...params
+        // 使用传入的参数覆盖默认值
+      };
+      console.log("[Order] 调用后端接口创建订单:", {
+        url: "/order/checkout",
+        orderType: orderData.type,
+        platform: orderData.platform,
+        isDeposit: orderData.is_deposit,
+        customerId: orderData.customer_id,
+        bookingsCount: ((_d = orderData.bookings) == null ? void 0 : _d.length) || 0,
+        relationProductsCount: ((_e = orderData.relation_products) == null ? void 0 : _e.length) || 0,
+        paymentsCount: ((_f = orderData.payments) == null ? void 0 : _f.length) || 0,
+        paymentsMethods: ((_g = orderData.payments) == null ? void 0 : _g.map((p) => p.code)) || []
+      });
+      const response = await this.request.post("/order/checkout", orderData);
+      console.log("[Order] 订单创建成功，后端响应:", {
+        success: !!response,
+        hasOrderId: !!(((_h = response == null ? void 0 : response.data) == null ? void 0 : _h.order_id) || (response == null ? void 0 : response.order_id))
+      });
+      return response;
+    } catch (error) {
+      console.error("[Order] createOrderByCheckout 创建订单失败:", error);
+      throw error;
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -18,6 +18,43 @@ export interface CommitOrderParams {
         platform?: 'pc' | 'h5';
     };
 }
+/**
+ * 支付项数据
+ */
+export interface PaymentItemData {
+    /** 当前支付项的唯一 ID */
+    uuid: string;
+    /** 当前支付方式付出去多少钱 */
+    amount: string;
+    /** 支付类型代码 */
+    code: string;
+    /** 支付类型id */
+    id: number;
+    /** 支付类型名称 */
+    name: string;
+    /** 支付类型 */
+    type: string;
+    /** 是否已同步到后端 */
+    isSynced?: boolean;
+}
+/**
+ * Checkout 专用订单创建参数
+ */
+export interface CheckoutOrderParams {
+    type: 'virtual' | 'appointment_booking';
+    platform: 'PC' | 'H5';
+    sales_channel?: string;
+    order_sales_channel?: string;
+    bookings?: any[];
+    shop_note?: string;
+    schedule_date?: string;
+    is_deposit?: number;
+    relation_products?: any[];
+    relation_forms?: any[];
+    payments?: PaymentItemData[];
+    customer_id?: string;
+    [key: string]: any;
+}
 /**
  * 订单模块 API
  */
@@ -40,4 +77,10 @@ export interface OrderModuleAPI {
      * @param params 订单信息
      */
     submitOrder: (params: CommitOrderParams) => Promise<void>;
+    /**
+     * Checkout 专用：创建订单到后端
+     * @param params 订单参数
+     * @returns 后端返回的订单数据
+     */
+    createOrderByCheckout: (params: CheckoutOrderParams) => Promise<any>;
 }

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

@@ -8,4 +8,12 @@ export declare class CashPaymentImpl implements CashPayment {
     constructor(paymentModule: PaymentModule);
     processCashPayment(amount: number, orderUuid: string): Promise<void>;
     getCashBalance(): Promise<number>;
+    /**
+     * 获取推荐支付金额
+     * 基于目标金额和货币类型，返回最优支付金额建议
+     * @param money 目标支付金额
+     * @param currency 货币代码 (如: 'CNY', 'USD', 'EUR' 等)
+     * @returns 推荐支付金额数组
+     */
+    getRecommendedAmount(money: number, currency: string): number[];
 }

package/lib/modules/Payment/cash.js

@@ -22,6 +22,7 @@ __export(cash_exports, {
   CashPaymentImpl: () => CashPaymentImpl
 });
 module.exports = __toCommonJS(cash_exports);
+var import_cashRecommendationAlgorithm = require("./cashRecommendationAlgorithm");
 var CashPaymentImpl = class {
   constructor(paymentModule) {
     this.paymentModule = paymentModule;
@@ -39,11 +40,23 @@ var CashPaymentImpl = class {
       type: cashMethod.type,
       voucher_id: ""
     };
-    await this.paymentModule.pushPaymentAsync(orderUuid, paymentItem);
+    await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
   }
   async getCashBalance() {
     return 0;
   }
+  /**
+   * 获取推荐支付金额
+   * 基于目标金额和货币类型，返回最优支付金额建议
+   * @param money 目标支付金额
+   * @param currency 货币代码 (如: 'CNY', 'USD', 'EUR' 等)
+   * @returns 推荐支付金额数组
+   */
+  getRecommendedAmount(money, currency) {
+    const upperCurrency = currency.toUpperCase();
+    const denominations = import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS[upperCurrency] || import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS["DEFAULT"];
+    return (0, import_cashRecommendationAlgorithm.recommendOptimalPayments)(money, denominations);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -0,0 +1,22 @@
+/**
+ * 现金支付推荐算法
+ *
+ * 核心原理：
+ * 1. 每个推荐金额都应该是独立的最优组合
+ * 2. 不推荐在已有最优解基础上添加额外面额的组合
+ * 3. 优先推荐使用不同数量币种的组合
+ * 4. 根据组合判断去重，避免扩展组合
+ */
+/**
+ * 常见国家货币面额配置
+ */
+export declare const CURRENCY_DENOMINATIONS: Record<string, number[]>;
+/**
+ * 最优支付金额推荐算法
+ * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ *
+ * @param targetAmount 目标金额
+ * @param denominations 币种面值数组
+ * @returns 推荐支付金额数组
+ */
+export declare function recommendOptimalPayments(targetAmount: number, denominations: number[]): number[];

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -0,0 +1,342 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Payment/cashRecommendationAlgorithm.ts
+var cashRecommendationAlgorithm_exports = {};
+__export(cashRecommendationAlgorithm_exports, {
+  CURRENCY_DENOMINATIONS: () => CURRENCY_DENOMINATIONS,
+  recommendOptimalPayments: () => recommendOptimalPayments
+});
+module.exports = __toCommonJS(cashRecommendationAlgorithm_exports);
+var CURRENCY_DENOMINATIONS = {
+  // 美元
+  "USD": [100, 50, 20, 10, 5, 2, 1, 0.5, 0.25, 0.1, 0.05, 0.01],
+  // 人民币
+  "CNY": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  "RMB": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  // 欧元
+  "EUR": [500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  // 日元
+  "JPY": [1e4, 5e3, 2e3, 1e3, 500, 100, 50, 10, 5, 1],
+  // 英镑
+  "GBP": [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  // 澳元
+  "AUD": [100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  // 加元
+  "CAD": [100, 50, 20, 10, 5, 2, 1, 0.25, 0.1, 0.05],
+  // 港元
+  "HKD": [1e3, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  // 新台币
+  "TWD": [2e3, 1e3, 500, 200, 100, 50, 10, 5, 1],
+  // 韩元
+  "KRW": [5e4, 1e4, 5e3, 1e3, 500, 100, 50, 10, 5, 1],
+  // 新加坡元
+  "SGD": [1e4, 1e3, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
+  // 瑞士法郎
+  "CHF": [1e3, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05],
+  // 默认通用面额（如果币种不在列表中）
+  "DEFAULT": [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
+};
+function recommendOptimalPayments(targetAmount, denominations) {
+  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+    return [];
+  }
+  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
+    return [Math.ceil(targetAmount)];
+  }
+  const maxReasonableDenom = targetAmount * 5;
+  const validDenoms = denominations.filter((denom) => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8);
+  if (validDenoms.length === 0) {
+    return [Math.ceil(targetAmount)];
+  }
+  try {
+    const precision = 100;
+    const target = Math.round(targetAmount * precision);
+    const denoms = validDenoms.map((d) => Math.round(d * precision)).sort((a, b) => b - a);
+    const paymentOptions = [];
+    const exactCombination = findExactCombination(target, denoms, precision);
+    if (exactCombination) {
+      paymentOptions.push(exactCombination);
+    }
+    for (let i = 0; i < Math.min(denoms.length, 6); i++) {
+      const denom = denoms[i];
+      const count = Math.ceil(target / denom);
+      const sum = count * denom;
+      if (sum >= target && count <= 12) {
+        paymentOptions.push({
+          combination: Array(count).fill(denom / precision),
+          sum: sum / precision,
+          coinCount: count,
+          denomTypes: 1
+        });
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 1, 5); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length, 6); j++) {
+        const denom1 = denoms[i];
+        const denom2 = denoms[j];
+        const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
+        const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
+        for (let count1 = 1; count1 <= maxCount1; count1++) {
+          for (let count2 = 1; count2 <= maxCount2; count2++) {
+            const sum = count1 * denom1 + count2 * denom2;
+            if (sum >= target) {
+              const combination = [
+                ...Array(count1).fill(denom1 / precision),
+                ...Array(count2).fill(denom2 / precision)
+              ];
+              paymentOptions.push({
+                combination,
+                sum: sum / precision,
+                coinCount: count1 + count2,
+                denomTypes: 2
+              });
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 2, 3); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length - 1, 4); j++) {
+        for (let k = j + 1; k < Math.min(denoms.length, 5); k++) {
+          const denom1 = denoms[i];
+          const denom2 = denoms[j];
+          const denom3 = denoms[k];
+          const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 5);
+          const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 6);
+          const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
+          for (let count1 = 1; count1 <= maxCount1; count1++) {
+            for (let count2 = 1; count2 <= maxCount2; count2++) {
+              for (let count3 = 1; count3 <= maxCount3; count3++) {
+                const sum = count1 * denom1 + count2 * denom2 + count3 * denom3;
+                if (sum >= target) {
+                  const combination = [
+                    ...Array(count1).fill(denom1 / precision),
+                    ...Array(count2).fill(denom2 / precision),
+                    ...Array(count3).fill(denom3 / precision)
+                  ];
+                  paymentOptions.push({
+                    combination,
+                    sum: sum / precision,
+                    coinCount: count1 + count2 + count3,
+                    denomTypes: 3
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 3, 2); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length - 2, 3); j++) {
+        for (let k = j + 1; k < Math.min(denoms.length - 1, 4); k++) {
+          for (let l = k + 1; l < Math.min(denoms.length, 5); l++) {
+            const denom1 = denoms[i];
+            const denom2 = denoms[j];
+            const denom3 = denoms[k];
+            const denom4 = denoms[l];
+            const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 3);
+            const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 4);
+            const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 5);
+            const maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
+            for (let count1 = 1; count1 <= maxCount1; count1++) {
+              for (let count2 = 1; count2 <= maxCount2; count2++) {
+                for (let count3 = 1; count3 <= maxCount3; count3++) {
+                  for (let count4 = 1; count4 <= maxCount4; count4++) {
+                    const sum = count1 * denom1 + count2 * denom2 + count3 * denom3 + count4 * denom4;
+                    if (sum >= target) {
+                      const combination = [
+                        ...Array(count1).fill(denom1 / precision),
+                        ...Array(count2).fill(denom2 / precision),
+                        ...Array(count3).fill(denom3 / precision),
+                        ...Array(count4).fill(denom4 / precision)
+                      ];
+                      paymentOptions.push({
+                        combination,
+                        sum: sum / precision,
+                        coinCount: count1 + count2 + count3 + count4,
+                        denomTypes: 4
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (paymentOptions.length === 0) {
+      const minValidDenom = validDenoms.find((denom) => denom >= targetAmount);
+      if (minValidDenom) {
+        return [minValidDenom];
+      } else {
+        const maxDenom = Math.max(...validDenoms);
+        const count = Math.ceil(targetAmount / maxDenom);
+        return [count * maxDenom];
+      }
+    }
+    const uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
+    uniqueCombinations.sort((a, b) => {
+      if (a.denomTypes !== b.denomTypes) {
+        return a.denomTypes - b.denomTypes;
+      }
+      if (a.coinCount !== b.coinCount) {
+        return a.coinCount - b.coinCount;
+      }
+      return a.sum - b.sum;
+    });
+    const uniqueAmounts = /* @__PURE__ */ new Set();
+    const finalResults = [];
+    for (const item of uniqueCombinations) {
+      const roundedAmount = Math.round(item.sum * 100) / 100;
+      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
+        uniqueAmounts.add(roundedAmount);
+        finalResults.push(roundedAmount);
+      }
+    }
+    return finalResults.sort((a, b) => a - b);
+  } catch (error) {
+    console.warn("推荐支付金额计算出错:", error);
+    const safeAmount = Math.ceil(targetAmount);
+    return [targetAmount, safeAmount];
+  }
+}
+function findExactCombination(target, denoms, precision) {
+  function dfs(remaining, denomIndex, currentCombination) {
+    if (remaining === 0) {
+      return currentCombination;
+    }
+    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
+      return null;
+    }
+    const denom = denoms[denomIndex];
+    const maxCount = Math.min(Math.floor(remaining / denom), 8);
+    for (let count = maxCount; count >= 0; count--) {
+      const newCombination = [...currentCombination, ...Array(count).fill(denom)];
+      const result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
+      if (result) {
+        return result;
+      }
+    }
+    return null;
+  }
+  const exactMatch = dfs(target, 0, []);
+  if (exactMatch && exactMatch.length > 0) {
+    const denomTypes = new Set(exactMatch).size;
+    return {
+      combination: exactMatch.map((d) => d / precision),
+      sum: target / precision,
+      coinCount: exactMatch.length,
+      denomTypes
+    };
+  }
+  return null;
+}
+function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
+  const result = [];
+  combinations.sort((a, b) => {
+    if (a.denomTypes !== b.denomTypes) {
+      return a.denomTypes - b.denomTypes;
+    }
+    if (a.coinCount !== b.coinCount) {
+      return a.coinCount - b.coinCount;
+    }
+    return a.sum - b.sum;
+  });
+  for (let i = 0; i < combinations.length; i++) {
+    const current = combinations[i];
+    let shouldSkip = false;
+    for (let j = 0; j < result.length; j++) {
+      const existing = result[j];
+      if (isSameCombination(current.combination, existing.combination)) {
+        shouldSkip = true;
+        break;
+      }
+      if (isExtensionOf(current.combination, existing.combination)) {
+        shouldSkip = true;
+        break;
+      }
+    }
+    if (!shouldSkip) {
+      for (let j = result.length - 1; j >= 0; j--) {
+        if (isExtensionOf(result[j].combination, current.combination)) {
+          result.splice(j, 1);
+        }
+      }
+      result.push(current);
+    }
+  }
+  return result;
+}
+function isExtensionOf(combinationA, combinationB) {
+  if (combinationA.length <= combinationB.length) {
+    return false;
+  }
+  const countA = {};
+  const countB = {};
+  combinationA.forEach((coin) => {
+    countA[coin] = (countA[coin] || 0) + 1;
+  });
+  combinationB.forEach((coin) => {
+    countB[coin] = (countB[coin] || 0) + 1;
+  });
+  for (const coin in countB) {
+    if (!countA[coin] || countA[coin] < countB[coin]) {
+      return false;
+    }
+  }
+  let hasExtra = false;
+  for (const coin in countA) {
+    if (countA[coin] > (countB[coin] || 0)) {
+      hasExtra = true;
+      break;
+    }
+  }
+  return hasExtra;
+}
+function isSameCombination(combinationA, combinationB) {
+  if (combinationA.length !== combinationB.length) {
+    return false;
+  }
+  const countA = {};
+  const countB = {};
+  combinationA.forEach((coin) => {
+    countA[coin] = (countA[coin] || 0) + 1;
+  });
+  combinationB.forEach((coin) => {
+    countB[coin] = (countB[coin] || 0) + 1;
+  });
+  for (const coin in countA) {
+    if (countA[coin] !== (countB[coin] || 0)) {
+      return false;
+    }
+  }
+  for (const coin in countB) {
+    if (countB[coin] !== (countA[coin] || 0)) {
+      return false;
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CURRENCY_DENOMINATIONS,
+  recommendOptimalPayments
+});

package/lib/modules/Payment/eftpos.js

@@ -39,7 +39,7 @@ var EftposPaymentImpl = class {
       type: eftposMethod.type,
       voucher_id: ""
     };
-    await this.paymentModule.pushPaymentAsync(orderUuid, paymentItem);
+    await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
   }
   async checkDeviceStatus() {
     return true;