@be-link/ecommerce-trade-service-node-sdk 0.1.148 → 0.1.150

package/modules/member/pos/orderCore/types.d.ts

@@ -48,6 +48,25 @@ export declare namespace MemberOrderCoreService {
         /** 更新会员订单支付状态 */
         updatePayStatus(request: ByUser.Request.IUpdatePayStatus, req: any): Promise<void>;
     }
+    namespace ByInternal {
+        namespace Request {
+            interface IMemberOrderPaidMock {
+                /** 会员订单ID */
+                orderId: string;
+                /** 支付金额（单位：分），须与订单 actualAmount 一致 */
+                paidFee: number;
+                /** 模拟支付流水号，不传则 `mock_tx_{orderId}` */
+                transactionId?: string;
+            }
+        }
+    }
+    interface CoreByInternalController {
+        /**
+         * 会员订单支付成功 mock：不入队，直接执行与 PAID_CALLBACK 消费者一致的成功逻辑。
+         * 仅 non-prod。
+         */
+        memberOrderPaidMock(request: ByInternal.Request.IMemberOrderPaidMock, req: any): Promise<string>;
+    }
     namespace ByJob {
         namespace Request {
             interface IAutoCancelTimeoutOrders {

package/modules/member/ros/orderCore/types.d.ts

@@ -22,6 +22,27 @@ export declare namespace MemberRosOrderCoreService {
     interface CoreByWebController {
         /** B端发起会员订单退款申请 */
         memberOrderRefundCreate(request: ByWeb.Request.IMemberOrderRefundCreate, req: any): Promise<void>;
+        /**
+         * 与 memberOrderRefundCreate 同入参：预发 PPE mock，不发 PENDING MQ、不调微信申请退款，
+         * 权益回收成功后直接走退款成功 FSM。
+         */
+        memberOrderRefundCreateMock(request: ByWeb.Request.IMemberOrderRefundCreate, req: any): Promise<void>;
+    }
+    namespace ByInternal {
+        namespace Request {
+            interface IMemberOrderRefundMock {
+                /** 会员逆向单ID */
+                reverseOrderId: string;
+                /** @deprecated 不再参与 mock 逻辑，可省略 */
+                refundAmount?: number;
+                /** 退款终态：SUCCESS | CLOSED | ABNORMAL */
+                refundStatus?: 'SUCCESS' | 'CLOSED' | 'ABNORMAL';
+                /** 模拟微信退款单号 */
+                refundId?: string;
+            }
+        }
+    }
+    interface CoreByInternalController {
     }
     interface JobController {
         /** 会员逆向退款补偿任务（权益回收补偿 + 待退款重试） */

package/modules/member/ros/orderCore/webService.d.ts

@@ -3,6 +3,7 @@ import BaseService from '../../../BaseService';
 declare class MemberRosOrderCoreByWebService extends BaseService {
     protected prefixUrl: string;
     memberOrderRefundCreate(request: MemberRosOrderCoreService.ByWeb.Request.IMemberOrderRefundCreate): Promise<void>;
+    memberOrderRefundCreateMock(request: MemberRosOrderCoreService.ByWeb.Request.IMemberOrderRefundCreate): Promise<void>;
 }
 export declare const memberRosOrderCoreByWebService: MemberRosOrderCoreByWebService;
 export default memberRosOrderCoreByWebService;

package/modules/member/ros/orderCore/webService.js

@@ -24,12 +24,20 @@ let MemberRosOrderCoreByWebService = class MemberRosOrderCoreByWebService extend
     memberOrderRefundCreate(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.memberOrderRefundCreate), request);
     }
+    memberOrderRefundCreateMock(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.memberOrderRefundCreateMock), request);
+    }
 };
 __decorate([
     (0, tsoa_1.OperationId)('黑钻会员订单后台申请退款'),
     (0, tsoa_1.Post)('member-order-refund-create'),
     __param(0, (0, tsoa_1.Body)())
 ], MemberRosOrderCoreByWebService.prototype, "memberOrderRefundCreate", null);
+__decorate([
+    (0, tsoa_1.OperationId)('黑钻会员订单后台申请退款（mock，仅预发 PPE）'),
+    (0, tsoa_1.Post)('member-order-refund-create-mock'),
+    __param(0, (0, tsoa_1.Body)())
+], MemberRosOrderCoreByWebService.prototype, "memberOrderRefundCreateMock", null);
 MemberRosOrderCoreByWebService = __decorate([
     (0, tsoa_1.Route)('member/ros/core/web'),
     (0, tsoa_1.Tags)('MemberRosOrderCore')

package/modules/pos/orderQuery/internalService.d.ts

@@ -5,6 +5,7 @@ declare class OrderQueryByInternalService extends BaseService implements PosOrde
     getOrderByIdForClientBackend(request: PosOrderQueryService.ByInternal.Request.IGetOrderByIdForClientBackend): Promise<PosOrderQueryService.ByInternal.Response.IGetOrderByIdForClientBackend>;
     getOrderListForClientBackend(request: PosOrderQueryService.ByInternal.Request.IGetOrderListForClientBackend): Promise<PosOrderQueryService.ByInternal.Response.IGetOrderListForClientBackend>;
     getPaidUserIdsByLiveRoomId(request: PosOrderQueryService.ByInternal.Request.IGetPaidUserIdsByLiveRoomId): Promise<PosOrderQueryService.ByInternal.Response.IGetPaidUserIdsByLiveRoomId>;
+    countUserProductQuantity(request: PosOrderQueryService.ByInternal.Request.ICountUserProductQuantity): Promise<PosOrderQueryService.ByInternal.Response.ICountUserProductQuantity>;
     getUserDiscountAmount(request: PosOrderQueryService.ByInternal.Request.IGetUserDiscountAmount): Promise<PosOrderQueryService.ByInternal.Response.IGetUserDiscountAmount>;
     getOrderSavingAmount(request: PosOrderQueryService.ByInternal.Request.IGetOrderSavingAmount): Promise<PosOrderQueryService.ByInternal.Response.IGetOrderSavingAmount>;
     mgetOrderProductInfo(request: PosOrderQueryService.ByInternal.Request.IMgetOrderProductInfo): Promise<PosOrderQueryService.ByInternal.Response.IMgetOrderProductInfo[]>;

package/modules/pos/orderQuery/internalService.js

@@ -30,6 +30,9 @@ let OrderQueryByInternalService = class OrderQueryByInternalService extends Base
     getPaidUserIdsByLiveRoomId(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.getPaidUserIdsByLiveRoomId), request);
     }
+    countUserProductQuantity(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.countUserProductQuantity), request);
+    }
     getUserDiscountAmount(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.getUserDiscountAmount), request);
     }
@@ -58,6 +61,11 @@ __decorate([
     (0, tsoa_1.Post)('get-paid-user-ids-by-live-room-id'),
     __param(0, (0, tsoa_1.Body)())
 ], OrderQueryByInternalService.prototype, "getPaidUserIdsByLiveRoomId", null);
+__decorate([
+    (0, tsoa_1.OperationId)('统计用户购买商品份数（内部）'),
+    (0, tsoa_1.Post)('count-user-product-quantity'),
+    __param(0, (0, tsoa_1.Body)())
+], OrderQueryByInternalService.prototype, "countUserProductQuantity", null);
 __decorate([
     (0, tsoa_1.OperationId)('查询用户某段时间范围内累计优惠金额'),
     (0, tsoa_1.Post)('get-user-discount-amount'),

package/modules/pos/orderQuery/pandoraUserService.d.ts

@@ -3,6 +3,8 @@ import BaseService from '../../BaseService';
 declare class OrderQueryByPandoraUserService extends BaseService {
     protected prefixUrl: string;
     queryUserOrderList(request: PosOrderQueryService.ByPandoraUser.Request.IQueryUserOrderList): Promise<PosOrderQueryService.ByPandoraUser.Response.IQueryUserOrderList>;
+    queryStoreOrderList(request: PosOrderQueryService.ByPandoraUser.Request.IQueryStoreOrderList): Promise<PosOrderQueryService.ByPandoraUser.Response.IQueryStoreOrderList>;
+    queryStoreOrderListCount(request: PosOrderQueryService.ByPandoraUser.Request.IQueryStoreOrderListCount): Promise<PosOrderQueryService.ByPandoraUser.Response.IQueryStoreOrderListCount>;
 }
 export declare const queryByPandoraUserService: OrderQueryByPandoraUserService;
-export {};
+export default queryByPandoraUserService;

package/modules/pos/orderQuery/pandoraUserService.js

@@ -24,14 +24,31 @@ let OrderQueryByPandoraUserService = class OrderQueryByPandoraUserService extend
     queryUserOrderList(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.queryUserOrderList), request);
     }
+    queryStoreOrderList(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.queryStoreOrderList), request);
+    }
+    queryStoreOrderListCount(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.queryStoreOrderListCount), request);
+    }
 };
 __decorate([
     (0, tsoa_1.OperationId)('查询用户订单列表'),
     (0, tsoa_1.Post)('query-user-order-list'),
     __param(0, (0, tsoa_1.Body)())
 ], OrderQueryByPandoraUserService.prototype, "queryUserOrderList", null);
+__decorate([
+    (0, tsoa_1.OperationId)('B端门店订单列表（酒旅虚拟）'),
+    (0, tsoa_1.Post)('query-store-order-list'),
+    __param(0, (0, tsoa_1.Body)())
+], OrderQueryByPandoraUserService.prototype, "queryStoreOrderList", null);
+__decorate([
+    (0, tsoa_1.OperationId)('B端门店订单数量统计（酒旅虚拟）'),
+    (0, tsoa_1.Post)('query-store-order-list-count'),
+    __param(0, (0, tsoa_1.Body)())
+], OrderQueryByPandoraUserService.prototype, "queryStoreOrderListCount", null);
 OrderQueryByPandoraUserService = __decorate([
     (0, tsoa_1.Route)('pos/query/pandora-user'),
     (0, tsoa_1.Tags)('PosOrderQuery')
 ], OrderQueryByPandoraUserService);
 exports.queryByPandoraUserService = new OrderQueryByPandoraUserService();
+exports.default = exports.queryByPandoraUserService;

package/modules/pos/orderQuery/types.d.ts

@@ -66,6 +66,14 @@ export declare namespace PosOrderQueryService {
                 /** 直播间ID */
                 liveRoomId: string;
             }
+            interface ICountUserProductQuantity {
+                /** 用户ID */
+                userId: string;
+                /** 商品ID列表 */
+                productIds: string[];
+                /** 订单来源列表 */
+                sourceList?: ENUM.OrderSource[];
+            }
             interface IGetUserDiscountAmount {
                 /** 用户ID */
                 userId: string;
@@ -115,6 +123,8 @@ export declare namespace PosOrderQueryService {
                 /** 用户ID列表 */
                 userIds: string[];
             }
+            /** 商品ID -> 商品份数 */
+            type ICountUserProductQuantity = Record<string, number>;
             interface IGetUserDiscountAmount {
                 /** 累计优惠金额（分） */
                 totalDiscount: number;
@@ -205,6 +215,8 @@ export declare namespace PosOrderQueryService {
             getOrderListForClientBackend(request: Request.IGetOrderListForClientBackend, req: any): Promise<Response.IGetOrderListForClientBackend>;
             /** 根据直播间ID查询下单用户ID列表 */
             getPaidUserIdsByLiveRoomId(request: Request.IGetPaidUserIdsByLiveRoomId, req: any): Promise<Response.IGetPaidUserIdsByLiveRoomId>;
+            /** 统计用户购买的商品份数（排除已退款份数） */
+            countUserProductQuantity(request: Request.ICountUserProductQuantity, req: any): Promise<Response.ICountUserProductQuantity>;
             /** 查询用户某段时间范围内累计优惠金额 */
             getUserDiscountAmount(request: Request.IGetUserDiscountAmount, req: any): Promise<Response.IGetUserDiscountAmount>;
             /** 查询订单省钱金额 */
@@ -359,6 +371,11 @@ export declare namespace PosOrderQueryService {
             interface ILiveRoom {
                 liveRoomIds?: string[];
             }
+            /** B 端订单列表：按订单属性（TradeOrderAttributes）过滤 */
+            interface IOrderAttributesFilter {
+                /** 为 true 时仅查虚拟商品订单 */
+                isVirtual?: boolean;
+            }
             interface IOrderList {
                 /** 查询条件 */
                 conditions?: {
@@ -371,6 +388,8 @@ export declare namespace PosOrderQueryService {
                     store?: IStore;
                     /** 直播间 */
                     liveRoom?: ILiveRoom;
+                    /** 订单属性（扩展表） */
+                    orderAttributes?: IOrderAttributesFilter;
                 };
                 /**
                  * 分页（与 cursorPaging 二选一，优先 pagination；都不传时走 cursorPaging 的首页）
@@ -1113,6 +1132,52 @@ export declare namespace PosOrderQueryService {
                 /** 分页 */
                 pagination: Dto.IPagination;
             }
+            /**
+             * B 端门店订单列表
+             * 说明：分页 `page` 为从 0 开始的页码，与内部 `pageIndex` 一致；`page`、`pageSize` 均可省略，有默认值
+             */
+            interface IQueryStoreOrderList {
+                /** 页码，从 0 开始，默认 0 */
+                page?: number;
+                /** 每页条数，默认 10 */
+                pageSize?: number;
+                /** 门店 ID */
+                storeId: string;
+                /** 联系人姓名，精准匹配 receiverName */
+                contactName?: string;
+                /** 联系人手机号，精准匹配 receiverPhone */
+                contactPhone?: string;
+                /** 商品 ID 列表（等值匹配） */
+                productIds?: string[];
+                /** 下单时间起（毫秒） */
+                startTime?: number;
+                /** 下单时间止（毫秒） */
+                endTime?: number;
+                /**
+                 * 订单状态多选，仅允许 WAIT_RECEIVE、CLOSED；筛选项之间取交集（即 IN）
+                 * 不传时默认仅查询这两种状态
+                 */
+                orderStatus?: ENUM.OrderStatus[];
+            }
+            /**
+             * B 端门店订单数量统计（query-store-order-list-count）
+             * 校验与列表接口一致；响应仅 `ecommerceDepositCount` 为筛选得到的订单总数，另字段文档占位为空
+             */
+            interface IQueryStoreOrderListCount {
+                contactName?: string;
+                contactPhone?: string;
+                /** 来源名称（预留，当前不参与筛选） */
+                sourceName?: string;
+                storeId: string;
+                productIds?: string[];
+                startTime?: number;
+                endTime?: number;
+                orderStatus?: ENUM.OrderStatus[];
+                /** 商品结算分类多选，与列表默认三类酒旅结算分类取交集 */
+                productCategory?: PRODUCT_SERVICE_ENUM.PRODUCT_ENUM.CLASSIFICATION[];
+                /** 订单来源多选，仅可在默认四类来源内缩小范围 */
+                sourceChannel?: ENUM.OrderSource[];
+            }
         }
         namespace Response {
             interface IUserOrderListItem {
@@ -1187,10 +1252,42 @@ export declare namespace PosOrderQueryService {
                 /** 总数 */
                 total: number;
             }
+            /** B 端门店订单列表（酒旅虚拟品） */
+            interface IStoreOrderCard {
+                orderId: string;
+                /** 订单状态（与文档一致为数组） */
+                orderStatus: string[];
+                productImage: string;
+                /** 渠道标签，对应 OrderSource */
+                channelTag: string;
+                productTitle: string;
+                unitPrice: number;
+                quantity: number;
+                contactName?: string;
+                contactPhone?: string;
+                orderTime: number;
+            }
+            interface IQueryStoreOrderList {
+                list: IStoreOrderCard[];
+                total: number;
+            }
+            /** B 端门店订单数量统计（仅 ecommerceDepositCount 有值，与列表同筛选；余者为 null） */
+            interface IQueryStoreOrderListCount {
+                /** 文档占位，默认 null */
+                travelDepositCount: number | null;
+                /** 当前筛选条件下的订单总数（与 query-store-order-list 的 total 口径一致） */
+                ecommerceDepositCount: number;
+                /** 文档占位，默认 null */
+                travelFullPaymentCount: number | null;
+            }
         }
         interface QueryController {
             /** 查询用户订单列表 */
             queryUserOrderList(request: Request.IQueryUserOrderList, req: any): Promise<Response.IQueryUserOrderList>;
+            /** B 端门店订单列表（query-store-order-list） */
+            queryStoreOrderList(request: Request.IQueryStoreOrderList, req: any): Promise<Response.IQueryStoreOrderList>;
+            /** B 端门店订单数量（query-store-order-list-count） */
+            queryStoreOrderListCount(request: Request.IQueryStoreOrderListCount, req: any): Promise<Response.IQueryStoreOrderListCount>;
         }
     }
     namespace ByUser {

package/modules/ros/orderCore/types.d.ts

@@ -33,11 +33,30 @@ export declare namespace RosOrderCoreService {
                 /** 上传的图片/视频 */
                 attachmentUrls?: string[];
             }
+            /** 商家主动退款 mock（参数对齐 Web 端 IOrderCreate，仅非生产） */
+            interface IOrderCreateMerchantMock {
+                /** 订单ID */
+                orderId: string;
+                /** 退款类型 */
+                refundType?: ENUM.ReverseRefundType;
+                /** 退款金额（分） */
+                amount: number;
+                /** 申请原因 */
+                reason: string;
+                /** 商品份数 */
+                quantity?: number;
+                /** 已核销份数 */
+                verifiedNum?: number;
+                /** 未核销份数 */
+                unVerifiedNum?: number;
+            }
         }
         namespace Response {
             type IReverseOrderCreate = void;
             type IReverseOrderCancel = void;
             type IOrderCreateForQuick = void;
+            type IOrderCreateForQuickMock = void;
+            type IOrderCreateMerchantMock = void;
         }
     }
     namespace ByWeb {
@@ -166,6 +185,24 @@ export declare namespace RosOrderCoreService {
                 /** 优惠券码 */
                 couponCode: string;
             }
+            interface IMerchantRefundWithOutboundMock {
+                /** 操作人ID */
+                operatorId: string;
+                /** 正向订单ID */
+                orderId: string;
+                /** 退款类型 */
+                refundType?: ENUM.ReverseRefundType;
+                /** 退款金额 */
+                amount: number;
+                /** 申请原因 */
+                reason: string;
+                /** 商品份数 */
+                quantity?: number;
+                /** 已核销份数 */
+                verifiedNum?: number;
+                /** 未核销份数 */
+                unVerifiedNum?: number;
+            }
         }
         namespace Response {
             type IOrderCreateForVerifyCoupon = void;
@@ -175,6 +212,10 @@ export declare namespace RosOrderCoreService {
         orderCreate(request: ByUser.Request.IReverseOrderCreate, req: any): Promise<ByUser.Response.IReverseOrderCreate>;
         orderCancel(request: ByUser.Request.IReverseOrderCancel, req: any): Promise<ByUser.Response.IReverseOrderCancel>;
         orderCreateForQuick(request: ByUser.Request.IOrderCreateForQuick, req: any): Promise<ByUser.Response.IOrderCreateForQuick>;
+        /** 极速退款 mock：不落支付渠道；仅预发 NODE_ENV=ppe；操作人取 pandoraUserId */
+        orderCreateForQuickMock(request: ByUser.Request.IOrderCreateForQuick, req: any): Promise<ByUser.Response.IOrderCreateForQuickMock>;
+        /** 商家主动退款 mock：与 Web 商家创单一致，不落支付渠道；仅预发 NODE_ENV=ppe；操作人取 pandoraUserId */
+        orderCreateMerchantMock(request: ByUser.Request.IOrderCreateMerchantMock, req: any): Promise<ByUser.Response.IOrderCreateMerchantMock>;
     }
     interface CoreByWebController {
         orderApproval(request: ByWeb.Request.IOrderApproval, req: any): Promise<ByWeb.Response.IOrderApproval>;

package/modules/ros/orderCore/userService.d.ts

@@ -5,6 +5,8 @@ declare class RosOrderCoreByUserService extends BaseService implements RosOrderC
     orderCreate(request: RosOrderCoreService.ByUser.Request.IReverseOrderCreate): Promise<RosOrderCoreService.ByUser.Response.IReverseOrderCreate>;
     orderCancel(request: RosOrderCoreService.ByUser.Request.IReverseOrderCancel): Promise<RosOrderCoreService.ByUser.Response.IReverseOrderCancel>;
     orderCreateForQuick(request: RosOrderCoreService.ByUser.Request.IOrderCreateForQuick): Promise<RosOrderCoreService.ByUser.Response.IOrderCreateForQuick>;
+    orderCreateForQuickMock(request: RosOrderCoreService.ByUser.Request.IOrderCreateForQuick): Promise<RosOrderCoreService.ByUser.Response.IOrderCreateForQuickMock>;
+    orderCreateMerchantMock(request: RosOrderCoreService.ByUser.Request.IOrderCreateMerchantMock): Promise<RosOrderCoreService.ByUser.Response.IOrderCreateMerchantMock>;
 }
 export declare const orderCoreByUserService: RosOrderCoreByUserService;
 export default orderCoreByUserService;

package/modules/ros/orderCore/userService.js

@@ -30,6 +30,12 @@ let RosOrderCoreByUserService = class RosOrderCoreByUserService extends BaseServ
     orderCreateForQuick(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.orderCreateForQuick), request);
     }
+    orderCreateForQuickMock(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.orderCreateForQuickMock), request);
+    }
+    orderCreateMerchantMock(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.orderCreateMerchantMock), request);
+    }
 };
 __decorate([
     (0, tsoa_1.OperationId)('申请退款'),
@@ -46,6 +52,16 @@ __decorate([
     (0, tsoa_1.Post)('order-create-for-quick'),
     __param(0, (0, tsoa_1.Body)())
 ], RosOrderCoreByUserService.prototype, "orderCreateForQuick", null);
+__decorate([
+    (0, tsoa_1.OperationId)('用户申请急速退款（mock，仅预发 PPE）'),
+    (0, tsoa_1.Post)('order-create-for-quick-mock'),
+    __param(0, (0, tsoa_1.Body)())
+], RosOrderCoreByUserService.prototype, "orderCreateForQuickMock", null);
+__decorate([
+    (0, tsoa_1.OperationId)('商家主动退款（mock，仅预发 PPE）'),
+    (0, tsoa_1.Post)('order-create-merchant-mock'),
+    __param(0, (0, tsoa_1.Body)())
+], RosOrderCoreByUserService.prototype, "orderCreateMerchantMock", null);
 RosOrderCoreByUserService = __decorate([
     (0, tsoa_1.Route)('ros/core/user'),
     (0, tsoa_1.Tags)('RosOrderCore')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-trade-service-node-sdk",
-  "version": "0.1.148",
+  "version": "0.1.150",
   "description": "EcommerceTradeService Node.js SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",