@pisell/pisellos 3.0.76 → 3.0.78

package/dist/modules/Order/index.js

@@ -26,45 +26,30 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { BaseModule } from "../BaseModule";
 import { generateDuration, getAllDiscountList, mergeRelationForms } from "./utils";
 import { isNormalProduct } from "../Product/utils";
-import dayjs from 'dayjs';
 export var OrderModule = /*#__PURE__*/function (_BaseModule) {
   _inherits(OrderModule, _BaseModule);
   var _super = _createSuper(OrderModule);
-  // LoggerManager 实例
-
   function OrderModule(name, version) {
     var _this;
     _classCallCheck(this, OrderModule);
-    _this = _super.call(this, name || "order", version);
+    _this = _super.call(this, name, version);
     _defineProperty(_assertThisInitialized(_this), "defaultName", 'order');
     _defineProperty(_assertThisInitialized(_this), "defaultVersion", '1.0.0');
     _defineProperty(_assertThisInitialized(_this), "store", void 0);
     _defineProperty(_assertThisInitialized(_this), "request", void 0);
-    _defineProperty(_assertThisInitialized(_this), "logger", void 0);
     return _this;
   }
   _createClass(OrderModule, [{
     key: "initialize",
     value: function () {
       var _initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(core, options) {
-        var appPlugin, app;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               this.core = core;
               this.store = options.store;
               this.request = this.core.getPlugin('request');
-              appPlugin = this.core.getPlugin('app');
-              if (appPlugin) {
-                _context.next = 6;
-                break;
-              }
-              throw new Error('Order 模块需要 app 插件支持');
-            case 6:
-              app = appPlugin.getApp();
-              this.logger = app.logger;
-              this.logInfo('OrderModule initialized successfully');
-            case 9:
+            case 3:
             case "end":
               return _context.stop();
           }
@@ -75,50 +60,6 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
       }
       return initialize;
     }()
-    /**
-     * 记录信息日志
-     */
-  }, {
-    key: "logInfo",
-    value: function logInfo(title, metadata) {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'info',
-          title: "[OrderModule] ".concat(title),
-          metadata: metadata || {}
-        });
-      }
-    }
-
-    /**
-     * 记录警告日志
-     */
-  }, {
-    key: "logWarning",
-    value: function logWarning(title, metadata) {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'warning',
-          title: "[OrderModule] ".concat(title),
-          metadata: metadata || {}
-        });
-      }
-    }
-
-    /**
-     * 记录错误日志
-     */
-  }, {
-    key: "logError",
-    value: function logError(title, metadata) {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'error',
-          title: "[OrderModule] ".concat(title),
-          metadata: metadata || {}
-        });
-      }
-    }
   }, {
     key: "createOrder",
     value: function createOrder(params) {
@@ -181,11 +122,6 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "checkBeforeSubmitOrder",
     value: function checkBeforeSubmitOrder(params) {
-      var _params$cartItems;
-      this.logInfo('checkBeforeSubmitOrder called', {
-        cartItemsCount: ((_params$cartItems = params.cartItems) === null || _params$cartItems === void 0 ? void 0 : _params$cartItems.length) || 0,
-        type: params.type
-      });
       var cartItems = params.cartItems,
         type = params.type;
       if (type === 'holder') {
@@ -203,31 +139,15 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
     key: "submitOrder",
     value: function () {
       var _submitOrder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(order) {
-        var _order$query$cartItem, _params$bookings, _params$relation_prod;
         var url, query, fetchUrl, params;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              this.logInfo('submitOrder called', {
-                url: order.url,
-                orderType: order.query.type,
-                platform: order.query.platform,
-                cartItemsCount: ((_order$query$cartItem = order.query.cartItems) === null || _order$query$cartItem === void 0 ? void 0 : _order$query$cartItem.length) || 0
-              });
               url = order.url, query = order.query;
               fetchUrl = url || '/order/appointment';
               params = this.createOrder(query);
-              this.logInfo('Calling backend order API', {
-                url: fetchUrl,
-                orderType: params.type,
-                platform: params.platform,
-                isDeposit: params.is_deposit,
-                bookingsCount: ((_params$bookings = params.bookings) === null || _params$bookings === void 0 ? void 0 : _params$bookings.length) || 0,
-                relationProductsCount: ((_params$relation_prod = params.relation_products) === null || _params$relation_prod === void 0 ? void 0 : _params$relation_prod.length) || 0,
-                scheduleDate: params.schedule_date
-              });
               return _context2.abrupt("return", this.request.post(fetchUrl, params));
-            case 6:
+            case 4:
             case "end":
               return _context2.stop();
           }
@@ -238,147 +158,6 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
       }
       return submitOrder;
     }()
-    /**
-     * Checkout 专用：创建订单到后端
-     * 
-     * 专门为 Checkout 模块设计的订单创建方法，
-     * 直接调用 /order/checkout 接口创建订单
-     * 接收已经处理好的订单数据，无需再处理购物车
-     * 
-     * @param params Checkout 订单参数（已处理的订单数据）
-     * @returns 后端返回的订单数据（包含订单ID等）
-     */
-  }, {
-    key: "createOrderByCheckout",
-    value: (function () {
-      var _createOrderByCheckout = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
-        var _params$bookings2, _params$relation_prod2, _params$payments, _params$payments2, _params$bookings3, _params$relation_prod3, _params$payments3;
-        var _orderData$payments, _orderData$bookings, _orderData$relation_p, _orderData$payments2, _orderData$payments3, _orderData$bookings2, _orderData$relation_p2, _orderData$payments4, _orderData$payments5, _response$data, orderData, response;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              this.logInfo('createOrderByCheckout called', {
-                type: params.type,
-                platform: params.platform,
-                is_deposit: params.is_deposit,
-                customer_id: params.customer_id,
-                bookingsCount: ((_params$bookings2 = params.bookings) === null || _params$bookings2 === void 0 ? void 0 : _params$bookings2.length) || 0,
-                relationProductsCount: ((_params$relation_prod2 = params.relation_products) === null || _params$relation_prod2 === void 0 ? void 0 : _params$relation_prod2.length) || 0,
-                paymentsCount: ((_params$payments = params.payments) === null || _params$payments === void 0 ? void 0 : _params$payments.length) || 0,
-                depositAmount: params.deposit_amount,
-                productTaxFee: params.product_tax_fee,
-                note: params.note,
-                scheduleDate: params.schedule_date,
-                hasOrderId: !!params.order_id,
-                orderIdIncluded: params.order_id,
-                paymentMethods: ((_params$payments2 = params.payments) === null || _params$payments2 === void 0 ? void 0 : _params$payments2.map(function (p) {
-                  return p.code;
-                })) || []
-              });
-              console.log('[Order] createOrderByCheckout 开始创建订单:', {
-                type: params.type,
-                platform: params.platform,
-                is_deposit: params.is_deposit,
-                customer_id: params.customer_id,
-                bookingsCount: ((_params$bookings3 = params.bookings) === null || _params$bookings3 === void 0 ? void 0 : _params$bookings3.length) || 0,
-                relationProductsCount: ((_params$relation_prod3 = params.relation_products) === null || _params$relation_prod3 === void 0 ? void 0 : _params$relation_prod3.length) || 0,
-                paymentsCount: ((_params$payments3 = params.payments) === null || _params$payments3 === void 0 ? void 0 : _params$payments3.length) || 0
-              });
-              _context3.prev = 2;
-              // 构建订单数据，设置默认值并允许 params 覆盖
-              orderData = _objectSpread({
-                sales_channel: 'my_pisel',
-                order_sales_channel: 'online_store',
-                shop_note: '',
-                schedule_date: '',
-                is_deposit: 0,
-                bookings: [],
-                relation_products: [],
-                relation_forms: [],
-                payments: [],
-                is_full_overwrite_flag: 1
-              }, params);
-              if ((_orderData$payments = orderData.payments) !== null && _orderData$payments !== void 0 && _orderData$payments.length) {
-                orderData.small_ticket_data_flag = 1;
-              }
-
-              // 兜底策略，如果是第一次下单，没有 order_id，且没有 schedule_date，则设置为当前时间
-              if (!params.order_id && !orderData.schedule_date) {
-                orderData.schedule_date = dayjs().format('YYYY-MM-DD HH:mm:ss');
-              }
-              console.log('[Order] 调用后端接口创建订单:', {
-                url: '/order/checkout',
-                orderType: orderData.type,
-                platform: orderData.platform,
-                isDeposit: orderData.is_deposit,
-                customerId: orderData.customer_id,
-                bookingsCount: ((_orderData$bookings = orderData.bookings) === null || _orderData$bookings === void 0 ? void 0 : _orderData$bookings.length) || 0,
-                relationProductsCount: ((_orderData$relation_p = orderData.relation_products) === null || _orderData$relation_p === void 0 ? void 0 : _orderData$relation_p.length) || 0,
-                paymentsCount: ((_orderData$payments2 = orderData.payments) === null || _orderData$payments2 === void 0 ? void 0 : _orderData$payments2.length) || 0,
-                paymentsMethods: ((_orderData$payments3 = orderData.payments) === null || _orderData$payments3 === void 0 ? void 0 : _orderData$payments3.map(function (p) {
-                  return p.code;
-                })) || []
-              });
-
-              // 记录接口调用详情
-              this.logInfo('Calling backend checkout API', {
-                url: '/order/checkout',
-                orderType: orderData.type,
-                platform: orderData.platform,
-                isDeposit: orderData.is_deposit,
-                customerId: orderData.customer_id,
-                depositAmount: orderData.deposit_amount,
-                bookingsCount: ((_orderData$bookings2 = orderData.bookings) === null || _orderData$bookings2 === void 0 ? void 0 : _orderData$bookings2.length) || 0,
-                relationProductsCount: ((_orderData$relation_p2 = orderData.relation_products) === null || _orderData$relation_p2 === void 0 ? void 0 : _orderData$relation_p2.length) || 0,
-                paymentsCount: ((_orderData$payments4 = orderData.payments) === null || _orderData$payments4 === void 0 ? void 0 : _orderData$payments4.length) || 0,
-                paymentMethods: ((_orderData$payments5 = orderData.payments) === null || _orderData$payments5 === void 0 ? void 0 : _orderData$payments5.map(function (p) {
-                  return {
-                    code: p.code,
-                    amount: p.amount,
-                    type: p.type,
-                    hasVoucherId: !!p.voucher_id,
-                    orderPaymentType: p.order_payment_type
-                  };
-                })) || [],
-                productTaxFee: orderData.product_tax_fee,
-                note: orderData.note,
-                scheduleDate: orderData.schedule_date,
-                hasOrderId: !!orderData.order_id,
-                smallTicketDataFlag: orderData.small_ticket_data_flag
-              });
-
-              // 调用后端接口
-              _context3.next = 10;
-              return this.request.post('/order/checkout', orderData);
-            case 10:
-              response = _context3.sent;
-              this.logInfo('Order API called successfully', {
-                response: response
-              });
-              console.log('[Order] 订单创建成功，后端响应:', {
-                success: !!response,
-                hasOrderId: !!(response !== null && response !== void 0 && (_response$data = response.data) !== null && _response$data !== void 0 && _response$data.order_id || response !== null && response !== void 0 && response.order_id)
-              });
-              return _context3.abrupt("return", response);
-            case 16:
-              _context3.prev = 16;
-              _context3.t0 = _context3["catch"](2);
-              console.error('[Order] createOrderByCheckout 创建订单失败:', _context3.t0);
-              this.logInfo('Order API called failed', {
-                error: _context3.t0 instanceof Error ? _context3.t0.message : String(_context3.t0)
-              });
-              throw _context3.t0;
-            case 21:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[2, 16]]);
-      }));
-      function createOrderByCheckout(_x4) {
-        return _createOrderByCheckout.apply(this, arguments);
-      }
-      return createOrderByCheckout;
-    }())
   }]);
   return OrderModule;
 }(BaseModule);

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

@@ -19,45 +19,6 @@ export interface CommitOrderParams {
         extraData?: Record<string, any>;
     };
 }
-/**
- * 支付项数据
- */
-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;
-    /** 小票数据标记，当有支付项时设置为1 */
-    small_ticket_data_flag?: number;
-    [key: string]: any;
-}
 /**
  * 订单模块 API
  */
@@ -80,10 +41,4 @@ export interface OrderModuleAPI {
      * @param params 订单信息
      */
     submitOrder: (params: CommitOrderParams) => Promise<void>;
-    /**
-     * Checkout 专用：创建订单到后端
-     * @param params 订单参数
-     * @returns 后端返回的订单数据
-     */
-    createOrderByCheckout: (params: CheckoutOrderParams) => Promise<any>;
 }

package/dist/modules/Order/types.js

@@ -10,14 +10,6 @@ export var OrderHooks = /*#__PURE__*/function (OrderHooks) {
  * 订单信息
  */
 
-/**
- * 支付项数据
- */
-
-/**
- * Checkout 专用订单创建参数
- */
-
 /**
  * 订单模块 API
  */

package/dist/modules/Order/utils.js

@@ -56,7 +56,7 @@ export var getAllDiscountList = function getAllDiscountList(cartItem) {
   var _cartItem$_origin, _cartItem$_origin2;
   var discountList = (cartItem === null || cartItem === void 0 || (_cartItem$_origin = cartItem._origin) === null || _cartItem$_origin === void 0 || (_cartItem$_origin = _cartItem$_origin.product) === null || _cartItem$_origin === void 0 ? void 0 : _cartItem$_origin.discount_list) || [];
   ((cartItem === null || cartItem === void 0 || (_cartItem$_origin2 = cartItem._origin) === null || _cartItem$_origin2 === void 0 || (_cartItem$_origin2 = _cartItem$_origin2.product) === null || _cartItem$_origin2 === void 0 ? void 0 : _cartItem$_origin2.product_bundle) || []).forEach(function (item) {
-    discountList = [].concat(_toConsumableArray(discountList), _toConsumableArray((item === null || item === void 0 ? void 0 : item.discount_list) || []));
+    discountList = [].concat(_toConsumableArray(discountList), _toConsumableArray(item.discount_list || []));
     item.discount_list = undefined;
   });
   return discountList;

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

@@ -1,191 +1,16 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
-import { RequestPlugin } from '../../plugins';
 import { BaseModule } from '../BaseModule';
-import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPassPayment, RoundingRule, RoundingInterval, RoundingResult } from './types';
-export * from './types';
-export { generateRequestUniqueId };
-/**
- * 生成请求唯一ID
- * 格式: 年月日时分秒毫秒+4位随机数
- * 示例: 20241201143025123456
- */
-declare function generateRequestUniqueId(): string;
-/**
- * 支付模块实现
- *
- * 负责处理支付相关的数据管理和本地存储
- */
+import { Payment, PaymentModuleAPI, PaymentMethod, PaymentStatus } from './types';
 export declare class PaymentModule extends BaseModule implements Module, PaymentModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    request: RequestPlugin;
-    private app;
-    private store;
-    private dbManager;
-    private logger;
-    protected otherParams: any;
-    cash: CashPayment;
-    eftpos: EftposPayment;
-    wallet: WalletPassPayment;
+    private state;
     constructor(name?: string, version?: string);
-    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    /**
-     * 记录信息日志
-     */
-    logInfo(title: string, metadata?: any): void;
-    /**
-     * 记录警告日志
-     */
-    logWarning(title: string, metadata?: any): void;
-    /**
-     * 记录错误日志
-     */
-    logError(title: string, error?: any, metadata?: any): void;
-    /**
-     * 记录调试日志
-     */
-    logDebug(title: string, metadata?: any): void;
-    /**
-     * 网络恢复以后，尝试执行队列
-     *
-     */
-    private registerNetworkHandlers;
-    /**
-     * 获取支付方式列表
-     */
-    getPayMethodListAsync(): Promise<PaymentMethod[]>;
-    /**
-     * 后台刷新支付方式列表
-     */
-    private refreshPaymentMethodsInBackground;
-    /**
-     * 检查支付方式列表是否有变化
-     */
-    private hasPaymentMethodsChanged;
-    /**
-     * 获取订单列表
-     */
-    getOrderListAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 根据订单UUID获取支付订单（新方法）
-     */
-    getPaymentOrderByUuidAsync(orderUuid: string): Promise<PaymentOrder | null>;
-    /**
-     * 创建支付订单（新方法，专注支付数据）
-     */
-    createPaymentOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
-    /**
-     * 删除支付订单（新方法）
-     */
-    deletePaymentOrderAsync(orderUuid: string): Promise<void>;
-    /**
-     * 更新订单
-     */
-    updateOrderAsync(orderUuid: string, params: Partial<PaymentOrder>): Promise<void>;
-    /**
-     * 基于UUID替换订单ID
-     *
-     * 此方法用于将本地虚拟订单ID替换为真实的订单ID。
-     * 当前端模拟下单流程完成后，后端返回真实订单ID时调用此方法。
-     *
-     * @param orderUuid 订单的UUID
-     * @param newOrderId 新的订单ID (来自后端)
-     * @returns 更新后的订单对象，如果订单不存在则返回null
-     */
-    replaceOrderIdByUuidAsync(orderUuid: string, newOrderId: string): Promise<PaymentOrder | null>;
-    /**
-     * 获取支付项（新方法）
-     *
-     * @param orderUuid 订单UUID
-     * @param includeVoided 是否包含已撤销的支付项，默认为false
-     * @returns 支付项数组
-     */
-    getPaymentItemsAsync(orderUuid: string, includeVoided?: boolean): Promise<PaymentItem[]>;
-    /**
-     * 获取所有支付项（包括已撤销的）
-     *
-     * @param orderUuid 订单UUID
-     * @returns 所有支付项数组（包括撤销的）
-     */
-    getAllPaymentItemsAsync(orderUuid: string): Promise<PaymentItem[]>;
-    /**
-     * 为某个订单添加支付项（新方法）
-     */
-    addPaymentItemAsync(orderUuid: string, paymentItem: PaymentItemInput): Promise<void>;
-    /**
-     * 删除一个支付项 - 标记删除而非物理删除
-     */
-    deletePaymentAsync(orderUuid: string, paymentUuid: string): Promise<void>;
-    /**
-     * 批量更新代金券类支付项（覆盖更新）
-     *
-     * 删除所有现有的带 voucher_id 的支付项，然后添加新的代金券支付项
-     * 这是一个覆盖式更新，确保代金券支付项的一致性
-     */
-    updateVoucherPaymentItemsAsync(orderUuid: string, voucherPaymentItems: PaymentItemInput[]): Promise<void>;
-    /**
-     * 更新一个支付项
-     */
-    updatePaymentAsync(orderUuid: string, paymentUuid: string, params: PaymentUpdateFields): Promise<void>;
-    /**
-     * 提交支付
-     */
-    submitPayAsync(orderUuid?: string): Promise<{
-        status: 'success' | 'failed';
-    }>;
-    /**
-     * 提交单个订单的支付（推送到任务队列）
-     */
-    private submitSingleOrderPayment;
-    /**
-     * 获取订单剩余待付金额
-     */
-    getRemainingOrderAmountAsync(orderUuid: string): Promise<number>;
-    /**
-     * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
-     */
-    getRemainingOrderAmountWithInputAsync(inputAmount: string | number, orderUuid: string): Promise<number>;
-    /**
-     * 重新计算订单金额
-     */
-    private recalculateOrderAmount;
-    /**
-     * 获取现金支付方式
-     */
-    getCashPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 获取Eftpos支付方式
-     */
-    getEftposPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 获取钱包支付方式
-     */
-    getWalletPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 确保支付模块所需的数据库表已创建
-     */
-    private ensurePaymentTables;
-    /**
-     * 获取部分支付的订单
-     */
-    getPartiallyPaidOrdersAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 智能金额舍入
-     *
-     * 根据指定的舍入间隔和规则对金额进行舍入处理
-     *
-     * @param originalAmount 原始金额
-     * @param interval 舍入间隔 (0.05, 0.1, 0.5, 1)
-     * @param rule 舍入规则 (standard, standard_down, always_up, always_down)
-     * @returns 舍入结果详情（包含原始金额、舍入后金额和舍入差额）
-     */
-    roundAmountAsync(originalAmount: number | string, interval: RoundingInterval | number, rule: RoundingRule | string): Promise<RoundingResult>;
-    /**
-     * 标准舍入处理（处理中点情况）
-     *
-     * @param value 要舍入的值
-     * @param midpointUp 中点是否向上舍入
-     * @returns 舍入后的值
-     */
-    private standardRound;
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    processPayment(paymentId: string): Promise<void>;
+    getPayment(paymentId: string): Promise<Payment>;
+    getPaymentHistory(): Promise<Payment[]>;
+    refund(paymentId: string): Promise<void>;
+    getAvailablePaymentMethods(): PaymentMethod[];
+    checkPaymentStatus(paymentId: string): Promise<PaymentStatus>;
 }