@be-link/ecommerce-promotion-service-node-sdk 0.1.25 → 0.1.26

package/enum.d.ts

@@ -414,4 +414,71 @@ export declare namespace ENUM {
             OTHER = "OTHER"
         }
     }
+    namespace TASK_ENUM {
+        /** 任务状态 */
+        enum TASK_STATUS {
+            /** 待处理 */
+            PENDING = "PENDING",
+            /** 处理中 */
+            PROCESSING = "PROCESSING",
+            /** 已完成 */
+            COMPLETED = "COMPLETED",
+            /** 已撤回 */
+            CANCELLED = "CANCELLED",
+            /** 失败 */
+            FAILED = "FAILED"
+        }
+        /** 任务状态中文 */
+        enum TASK_STATUS_CHINESE {
+            PENDING = "\u5F85\u5904\u7406",
+            PROCESSING = "\u5904\u7406\u4E2D",
+            COMPLETED = "\u5DF2\u5B8C\u6210",
+            CANCELLED = "\u5DF2\u64A4\u56DE"
+        }
+        /** 变动类型 */
+        enum CHANGE_TYPE {
+            /** 增加积分 */
+            ADD_POINTS = "ADD_POINTS",
+            /** 扣减积分 */
+            DEDUCT_POINTS = "DEDUCT_POINTS",
+            /** 发放优惠券 */
+            ISSUE_COUPON = "ISSUE_COUPON",
+            /** 作废优惠券 */
+            ABANDON_COUPON = "ABANDON_COUPON"
+        }
+        /** 变动类型中文 */
+        enum CHANGE_TYPE_CHINESE {
+            ADD_POINTS = "\u589E\u52A0\u79EF\u5206",
+            DEDUCT_POINTS = "\u6263\u51CF\u79EF\u5206",
+            ISSUE_COUPON = "\u53D1\u653E\u4F18\u60E0\u5238",
+            ABANDON_COUPON = "\u4F5C\u5E9F\u4F18\u60E0\u5238"
+        }
+        /** 资产类型 */
+        enum ASSET_TYPE {
+            /** 积分 */
+            POINTS = "POINTS",
+            /** 优惠券 */
+            COUPON = "COUPON"
+        }
+        /** 资产类型中文 */
+        enum ASSET_TYPE_CHINESE {
+            POINTS = "\u79EF\u5206",
+            COUPON = "\u4F18\u60E0\u5238"
+        }
+        /** 明细处理状态 */
+        enum DETAIL_STATUS {
+            /** 待处理 */
+            PENDING = "PENDING",
+            /** 成功 */
+            SUCCESS = "SUCCESS",
+            /** 失败 */
+            FAILED = "FAILED"
+        }
+        /** 明细处理状态中文 */
+        enum DETAIL_STATUS_CHINESE {
+            PENDING = "\u5F85\u5904\u7406",
+            SUCCESS = "\u6210\u529F",
+            FAILED = "\u5931\u8D25"
+        }
+    }
 }

package/enum.js

@@ -469,4 +469,80 @@ var ENUM;
             ExchangeType["OTHER"] = "OTHER";
         })(ExchangeType = POINT_MALL.ExchangeType || (POINT_MALL.ExchangeType = {}));
     })(POINT_MALL = ENUM.POINT_MALL || (ENUM.POINT_MALL = {}));
+    let TASK_ENUM;
+    (function (TASK_ENUM) {
+        /** 任务状态 */
+        let TASK_STATUS;
+        (function (TASK_STATUS) {
+            /** 待处理 */
+            TASK_STATUS["PENDING"] = "PENDING";
+            /** 处理中 */
+            TASK_STATUS["PROCESSING"] = "PROCESSING";
+            /** 已完成 */
+            TASK_STATUS["COMPLETED"] = "COMPLETED";
+            /** 已撤回 */
+            TASK_STATUS["CANCELLED"] = "CANCELLED";
+            /** 失败 */
+            TASK_STATUS["FAILED"] = "FAILED";
+        })(TASK_STATUS = TASK_ENUM.TASK_STATUS || (TASK_ENUM.TASK_STATUS = {}));
+        /** 任务状态中文 */
+        let TASK_STATUS_CHINESE;
+        (function (TASK_STATUS_CHINESE) {
+            TASK_STATUS_CHINESE["PENDING"] = "\u5F85\u5904\u7406";
+            TASK_STATUS_CHINESE["PROCESSING"] = "\u5904\u7406\u4E2D";
+            TASK_STATUS_CHINESE["COMPLETED"] = "\u5DF2\u5B8C\u6210";
+            TASK_STATUS_CHINESE["CANCELLED"] = "\u5DF2\u64A4\u56DE";
+        })(TASK_STATUS_CHINESE = TASK_ENUM.TASK_STATUS_CHINESE || (TASK_ENUM.TASK_STATUS_CHINESE = {}));
+        /** 变动类型 */
+        let CHANGE_TYPE;
+        (function (CHANGE_TYPE) {
+            /** 增加积分 */
+            CHANGE_TYPE["ADD_POINTS"] = "ADD_POINTS";
+            /** 扣减积分 */
+            CHANGE_TYPE["DEDUCT_POINTS"] = "DEDUCT_POINTS";
+            /** 发放优惠券 */
+            CHANGE_TYPE["ISSUE_COUPON"] = "ISSUE_COUPON";
+            /** 作废优惠券 */
+            CHANGE_TYPE["ABANDON_COUPON"] = "ABANDON_COUPON";
+        })(CHANGE_TYPE = TASK_ENUM.CHANGE_TYPE || (TASK_ENUM.CHANGE_TYPE = {}));
+        /** 变动类型中文 */
+        let CHANGE_TYPE_CHINESE;
+        (function (CHANGE_TYPE_CHINESE) {
+            CHANGE_TYPE_CHINESE["ADD_POINTS"] = "\u589E\u52A0\u79EF\u5206";
+            CHANGE_TYPE_CHINESE["DEDUCT_POINTS"] = "\u6263\u51CF\u79EF\u5206";
+            CHANGE_TYPE_CHINESE["ISSUE_COUPON"] = "\u53D1\u653E\u4F18\u60E0\u5238";
+            CHANGE_TYPE_CHINESE["ABANDON_COUPON"] = "\u4F5C\u5E9F\u4F18\u60E0\u5238";
+        })(CHANGE_TYPE_CHINESE = TASK_ENUM.CHANGE_TYPE_CHINESE || (TASK_ENUM.CHANGE_TYPE_CHINESE = {}));
+        /** 资产类型 */
+        let ASSET_TYPE;
+        (function (ASSET_TYPE) {
+            /** 积分 */
+            ASSET_TYPE["POINTS"] = "POINTS";
+            /** 优惠券 */
+            ASSET_TYPE["COUPON"] = "COUPON";
+        })(ASSET_TYPE = TASK_ENUM.ASSET_TYPE || (TASK_ENUM.ASSET_TYPE = {}));
+        /** 资产类型中文 */
+        let ASSET_TYPE_CHINESE;
+        (function (ASSET_TYPE_CHINESE) {
+            ASSET_TYPE_CHINESE["POINTS"] = "\u79EF\u5206";
+            ASSET_TYPE_CHINESE["COUPON"] = "\u4F18\u60E0\u5238";
+        })(ASSET_TYPE_CHINESE = TASK_ENUM.ASSET_TYPE_CHINESE || (TASK_ENUM.ASSET_TYPE_CHINESE = {}));
+        /** 明细处理状态 */
+        let DETAIL_STATUS;
+        (function (DETAIL_STATUS) {
+            /** 待处理 */
+            DETAIL_STATUS["PENDING"] = "PENDING";
+            /** 成功 */
+            DETAIL_STATUS["SUCCESS"] = "SUCCESS";
+            /** 失败 */
+            DETAIL_STATUS["FAILED"] = "FAILED";
+        })(DETAIL_STATUS = TASK_ENUM.DETAIL_STATUS || (TASK_ENUM.DETAIL_STATUS = {}));
+        /** 明细处理状态中文 */
+        let DETAIL_STATUS_CHINESE;
+        (function (DETAIL_STATUS_CHINESE) {
+            DETAIL_STATUS_CHINESE["PENDING"] = "\u5F85\u5904\u7406";
+            DETAIL_STATUS_CHINESE["SUCCESS"] = "\u6210\u529F";
+            DETAIL_STATUS_CHINESE["FAILED"] = "\u5931\u8D25";
+        })(DETAIL_STATUS_CHINESE = TASK_ENUM.DETAIL_STATUS_CHINESE || (TASK_ENUM.DETAIL_STATUS_CHINESE = {}));
+    })(TASK_ENUM = ENUM.TASK_ENUM || (ENUM.TASK_ENUM = {}));
 })(ENUM || (exports.ENUM = ENUM = {}));

package/index.d.ts

@@ -10,4 +10,6 @@ export { pointsMallService } from './modules/pointsMall/service';
 export type { Service as PointsMallServiceTypes } from './modules/pointsMall/types';
 export { jobService } from './modules/job/service';
 export type { Service as JobServiceTypes } from './modules/job/types';
+export { taskService } from './modules/task/service';
+export type { Service as TaskServiceTypes } from './modules/task/types';
 export { ENUM as PROMOTION_ENUM } from './enum';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROMOTION_ENUM = exports.jobService = exports.pointsMallService = exports.pricingCalculationService = exports.configService = exports.couponService = exports.awardService = void 0;
+exports.PROMOTION_ENUM = exports.taskService = exports.jobService = exports.pointsMallService = exports.pricingCalculationService = exports.configService = exports.couponService = exports.awardService = void 0;
 var service_1 = require("./modules/award/service");
 Object.defineProperty(exports, "awardService", { enumerable: true, get: function () { return service_1.awardService; } });
 var service_2 = require("./modules/coupon/service");
@@ -13,6 +13,8 @@ var service_5 = require("./modules/pointsMall/service");
 Object.defineProperty(exports, "pointsMallService", { enumerable: true, get: function () { return service_5.pointsMallService; } });
 var service_6 = require("./modules/job/service");
 Object.defineProperty(exports, "jobService", { enumerable: true, get: function () { return service_6.jobService; } });
+var service_7 = require("./modules/task/service");
+Object.defineProperty(exports, "taskService", { enumerable: true, get: function () { return service_7.taskService; } });
 // 服务.模块.枚举名称.枚举值 示例: AWARD_ENUM.DISTRIBUTION_CHANNEL.ORDER
 var enum_1 = require("./enum");
 Object.defineProperty(exports, "PROMOTION_ENUM", { enumerable: true, get: function () { return enum_1.ENUM; } });

package/modules/BaseService.d.ts

@@ -8,7 +8,7 @@ export default abstract class BaseService {
     protected abstract prefixUrl: string;
     /** 子网域名 */
     protected readonly natDevHost = "http://192.168.3.168:8090/promotion";
-    protected readonly natProdHost = "http://192.168.87.191:8090/promotion";
+    protected readonly natProdHost = "http://10.1.0.97:8090/promotion";
     /** 公网域名 */
     protected readonly publicDevHost = "https://ecommerce-dev.wejourney.top/promotion";
     protected readonly publicProdHost = "";

package/modules/BaseService.js

@@ -13,7 +13,7 @@ class BaseService {
     constructor() {
         /** 子网域名 */
         this.natDevHost = 'http://192.168.3.168:8090/promotion';
-        this.natProdHost = 'http://192.168.87.191:8090/promotion';
+        this.natProdHost = 'http://10.1.0.97:8090/promotion';
         /** 公网域名 */
         this.publicDevHost = 'https://ecommerce-dev.wejourney.top/promotion';
         this.publicProdHost = '';

package/modules/award/types.d.ts

@@ -1,3 +1,4 @@
+import { TaskServiceTypes } from '../..';
 import { ENUM } from '../../enum';
 export declare namespace Service {
     namespace Entity {
@@ -47,8 +48,30 @@ export declare namespace Service {
     namespace Request {
         /** 发放奖励 */
         interface distributePrize {
-            /** 业务编号 */
-            bizNo: string;
+            /** 发奖记录ID */
+            id: string;
+            /** 用户ID */
+            userId: string;
+            /** 任务ID */
+            taskId: string;
+            /** 任务名称 */
+            taskName: string;
+            /** 任务类型 */
+            taskType: string;
+            /** 奖品类型 */
+            prizeType: string;
+            /** 直播间id */
+            liveStreamRoomId: string;
+            /** 业务ID */
+            bizId: string;
+            /** 发放数量 */
+            quantity: number;
+            /** 轮次编号（观看任务专用） */
+            roundNumber?: number;
+            /** 订单ID（满赠/买赠专用） */
+            orderId?: string;
+            /** 订单明细ID（买赠专用） */
+            orderDetailId?: string;
         }
         /** 作废奖励 */
         interface reversePrize {
@@ -102,6 +125,8 @@ export declare namespace Service {
             couponId: string;
             /** 用户ID */
             userId: string;
+            /** 数量 */
+            quantity?: number;
         }
     }
     namespace Response {
@@ -111,6 +136,8 @@ export declare namespace Service {
             success: boolean;
             /** 失败原因 */
             message?: string;
+            /** 失败详情 */
+            failureDetail?: TaskServiceTypes.Response.FailureListItem[];
         }
         /** 直播间积分&券发放统计响应 */
         interface queryLiveRoomDistributionStatsResponse {

package/modules/pricingCalculation/types.d.ts

@@ -153,6 +153,12 @@ export declare namespace Service {
                 originalAmount: number;
                 /** 券优惠金额（分） */
                 couponDiscountAmount: number;
+                /** 会员优惠金额（分） */
+                memberDiscount: {
+                    totalAmount: number;
+                    itemAmount: number;
+                    quantity: number;
+                };
                 /** 优惠后金额（分） */
                 discountedAmount: number;
                 /** 积分最高抵扣金额（分） */

package/modules/task/service.d.ts

@@ -0,0 +1,12 @@
+import { Service } from './types';
+import BaseService from '../BaseService';
+declare class TaskService extends BaseService implements Service.BatchTaskController {
+    protected prefixUrl: string;
+    createBatchTask(request: Service.Request.createBatchTask): Promise<void>;
+    getBatchTaskList(request: Service.Request.getBatchTaskList): Promise<Service.Response.getBatchTaskList>;
+    getBatchTaskDetail(request: Service.Request.getBatchTaskDetail): Promise<Service.Response.getBatchTaskDetail>;
+    cancelBatchTask(request: Service.Request.cancelBatchTask): Promise<void>;
+    getFailureList(request: Service.Request.getFailureList): Promise<Service.Response.getFailureList>;
+}
+export declare const taskService: TaskService;
+export {};

package/modules/task/service.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskService = void 0;
+const tsoa_1 = require("tsoa");
+const http_1 = require("../../utils/http");
+const BaseService_1 = __importDefault(require("../BaseService"));
+let TaskService = class TaskService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/task';
+    }
+    createBatchTask(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.createBatchTask), request);
+    }
+    getBatchTaskList(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getBatchTaskList), request);
+    }
+    getBatchTaskDetail(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getBatchTaskDetail), request);
+    }
+    cancelBatchTask(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.cancelBatchTask), request);
+    }
+    getFailureList(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getFailureList), request);
+    }
+};
+__decorate([
+    (0, tsoa_1.OperationId)('创建批量任务'),
+    (0, tsoa_1.Post)('create-batch-task'),
+    __param(0, (0, tsoa_1.Body)())
+], TaskService.prototype, "createBatchTask", null);
+__decorate([
+    (0, tsoa_1.OperationId)('获取批量任务列表'),
+    (0, tsoa_1.Post)('get-batch-task-list'),
+    __param(0, (0, tsoa_1.Body)())
+], TaskService.prototype, "getBatchTaskList", null);
+__decorate([
+    (0, tsoa_1.OperationId)('获取批量任务详情'),
+    (0, tsoa_1.Post)('get-batch-task-detail'),
+    __param(0, (0, tsoa_1.Body)())
+], TaskService.prototype, "getBatchTaskDetail", null);
+__decorate([
+    (0, tsoa_1.OperationId)('撤回批量任务'),
+    (0, tsoa_1.Post)('cancel-batch-task'),
+    __param(0, (0, tsoa_1.Body)())
+], TaskService.prototype, "cancelBatchTask", null);
+__decorate([
+    (0, tsoa_1.OperationId)('获取失败名单'),
+    (0, tsoa_1.Post)('get-failure-list'),
+    __param(0, (0, tsoa_1.Body)())
+], TaskService.prototype, "getFailureList", null);
+TaskService = __decorate([
+    (0, tsoa_1.Route)('task'),
+    (0, tsoa_1.Tags)('Task')
+], TaskService);
+exports.taskService = new TaskService();

package/modules/task/types.d.ts

@@ -0,0 +1,205 @@
+import { ENUM } from '../../enum';
+export declare namespace Service {
+    namespace Entity {
+        /** 批量任务基础信息 */
+        interface BatchTask {
+            /** 任务ID */
+            id: string;
+            /** 任务名称 */
+            taskName: string;
+            /** 变动类型：增加/发放/扣减/作废 */
+            changeType: ENUM.TASK_ENUM.CHANGE_TYPE;
+            /** 资产类型：积分/优惠券 */
+            assetType: ENUM.TASK_ENUM.ASSET_TYPE;
+            /** 资产ID（券ID或积分类型标识） */
+            assetId?: string;
+            /** 变动数量 */
+            changeAmount: number;
+            /** 变动人数 */
+            changeUserCount: number;
+            /** 成功数量 */
+            successCount: number;
+            /** 失败数量 */
+            failureCount: number;
+            /** Excel文件URL（COS链接） */
+            fileUrl: string;
+            /** 任务状态 */
+            status: ENUM.TASK_ENUM.TASK_STATUS;
+            /** 操作人ID */
+            operatorId: string;
+            /** 操作人姓名 */
+            operatorName: string;
+            /** 创建时间 */
+            createdAt: number;
+            /** 更新时间 */
+            updatedAt: number;
+            /** 失败详情（JSON字符串） */
+            failureDetail?: string;
+        }
+        /** 批量任务详情项 */
+        interface BatchTaskDetail {
+            /** 用户ID */
+            userId: string;
+            /** 变动数量 */
+            amount: number;
+            /** 处理状态 */
+            status: ENUM.TASK_ENUM.DETAIL_STATUS;
+            /** 失败原因 */
+            failureReason?: string;
+        }
+    }
+    namespace Request {
+        /** 创建批量任务 */
+        interface createBatchTask {
+            /** 任务名称 */
+            taskName: string;
+            /** 变动类型：增加/发放/扣减/作废 */
+            changeType: ENUM.TASK_ENUM.CHANGE_TYPE;
+            /** 资产类型：积分/优惠券 */
+            assetType: ENUM.TASK_ENUM.ASSET_TYPE;
+            /** 资产ID（券ID，积分类型可不填） */
+            assetId?: string;
+            /** 创建原因 */
+            reason: string;
+            /** Excel文件URL（COS链接） */
+            fileUrl: string;
+        }
+        /** 批量任务列表查询 */
+        interface getBatchTaskList {
+            /** 页码 */
+            pageIndex?: number;
+            /** 每页数量 */
+            pageSize?: number;
+            /** 任务ID */
+            taskId?: string;
+            /** 任务名称（模糊查询） */
+            taskName?: string;
+            /** 变动类型 */
+            changeType?: ENUM.TASK_ENUM.CHANGE_TYPE;
+            /** 资产类型 */
+            assetType?: ENUM.TASK_ENUM.ASSET_TYPE;
+            /** 任务状态 */
+            status?: ENUM.TASK_ENUM.TASK_STATUS;
+        }
+        /** 获取批量任务详情 */
+        interface getBatchTaskDetail {
+            /** 任务ID */
+            taskId: string;
+        }
+        /** 撤回批量任务 */
+        interface cancelBatchTask {
+            /** 任务ID */
+            taskId: string;
+        }
+        /** 获取失败名单 */
+        interface getFailureList {
+            /** 任务ID */
+            taskId: string;
+        }
+    }
+    namespace Response {
+        /** 批量任务列表项 */
+        interface BatchTaskListItem {
+            /** 任务ID */
+            id: string;
+            /** 任务名称 */
+            taskName: string;
+            /** 变动类型 */
+            changeType: ENUM.TASK_ENUM.CHANGE_TYPE;
+            /** 变动类型中文 */
+            changeTypeChinese: string;
+            /** 资产类型 */
+            assetType: ENUM.TASK_ENUM.ASSET_TYPE;
+            /** 资产类型中文 */
+            assetTypeChinese: string;
+            /** 变动人数 */
+            changeUserCount: number;
+            /** 成功数/失败数 */
+            successCount: number;
+            failureCount: number;
+            /** 操作人 */
+            operatorId: string;
+            /** 创建时间 */
+            createdAt: number;
+            /** 任务状态 */
+            status: ENUM.TASK_ENUM.TASK_STATUS;
+            /** 任务状态中文 */
+            statusChinese: string;
+        }
+        /** 批量任务列表响应 */
+        interface getBatchTaskList {
+            /** 总数 */
+            total: number;
+            /** 任务列表 */
+            list: BatchTaskListItem[];
+            /** 当前页码 */
+            pageIndex: number;
+            /** 每页数量 */
+            pageSize: number;
+        }
+        /** 批量任务详情响应 */
+        interface getBatchTaskDetail {
+            /** 任务ID */
+            id: string;
+            /** 任务名称 */
+            taskName: string;
+            /** 变动类型 */
+            changeType: ENUM.TASK_ENUM.CHANGE_TYPE;
+            /** 变动类型中文 */
+            changeTypeChinese: string;
+            /** 资产类型 */
+            assetType: ENUM.TASK_ENUM.ASSET_TYPE;
+            /** 资产类型中文 */
+            assetTypeChinese: string;
+            /** 资产ID */
+            assetId?: string;
+            /** 资产名称 */
+            assetName?: string;
+            /** 变动人数 */
+            changeUserCount: number;
+            /** 成功数/失败数 */
+            successCount: number;
+            failureCount: number;
+            /** Excel文件URL */
+            fileUrl: string;
+            /** 操作人 */
+            operatorId: string;
+            /** 创建时间 */
+            createdAt: number;
+            /** 更新时间 */
+            updatedAt: number;
+            /** 任务状态 */
+            status: ENUM.TASK_ENUM.TASK_STATUS;
+            /** 任务状态中文 */
+            statusChinese: string;
+        }
+        /** 失败名单项 */
+        interface FailureListItem {
+            /** 用户ID */
+            userId: string;
+            /** 变动数量 */
+            amount: number;
+            /** 失败原因 */
+            failureReason: string;
+        }
+        /** 失败名单响应 */
+        interface getFailureList {
+            /** 表头 */
+            headerMap: Record<string, string>;
+            /** 数据 */
+            data: Record<string, any>[];
+        }
+    }
+    interface BatchTaskController {
+        /** 创建批量任务 */
+        createBatchTask(request: Service.Request.createBatchTask, req: any): Promise<void>;
+        /** 获取批量任务列表 */
+        getBatchTaskList(request: Service.Request.getBatchTaskList, req: any): Promise<Service.Response.getBatchTaskList>;
+        /** 获取批量任务详情 */
+        getBatchTaskDetail(request: Service.Request.getBatchTaskDetail, req: any): Promise<Service.Response.getBatchTaskDetail>;
+        /** 撤回批量任务 */
+        cancelBatchTask(request: Service.Request.cancelBatchTask, req: any): Promise<void>;
+        /** 获取失败名单 */
+        getFailureList(request: Service.Request.getFailureList, req: any): Promise<Service.Response.getFailureList>;
+    }
+}

package/modules/task/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-promotion-service-node-sdk",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "EcommercePromotionService Node.js SDK",
   "main": "index.js",
   "types": "index.d.ts",
@@ -14,7 +14,7 @@
     "axios": "1.13.2",
     "axios-retry": "4.0.0",
     "uuid": "9.0.1",
-    "tsoa": "^6.6.0",
+    "tsoa": "6.6.0",
     "safe-stable-stringify": "2.5.0"
   },
   "scripts": {

package/utils/http.d.ts

@@ -9,25 +9,3 @@ declare module '@fastify/request-context' {
     }
 }
 export declare function callApi<T extends (...args: any[]) => Promise<any>>(url: string, request?: Parameters<T>[0]): Promise<Awaited<ReturnType<T>>>;
-export declare function getConnectionStats(): {
-    activeRequests: number;
-    totalRequests: number;
-    peakActiveRequests: number;
-    httpSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    httpsSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    config: {
-        maxSockets: number;
-        maxTotalSockets: number;
-        requestTimeout: number;
-        note: string;
-    };
-};
-export declare function resetPeakStats(): void;

package/utils/http.js

@@ -4,27 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callApi = callApi;
-exports.getConnectionStats = getConnectionStats;
-exports.resetPeakStats = resetPeakStats;
 const axios_1 = __importDefault(require("axios"));
 const uuid_1 = require("uuid");
 const axios_retry_1 = __importDefault(require("axios-retry"));
 const request_context_1 = require("@fastify/request-context");
-const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
-// 针对高并发优化配置 - 支持高并发场景
+// HTTP 连接池配置 - 支持 2000 QPS（响应时间 2秒）
 const HTTP_CONFIG = {
-    maxSockets: 2000, // 每个主机的最大socket连接数（支持2000并发）
-    maxFreeSockets: 1000, // 空闲socket保留数（50%复用率，提高连接复用效率）
-    maxTotalSockets: 3000, // 所有主机总socket数（单后端场景优化）
-    keepAliveMsecs: 30000, // 保持连接30秒（平衡资源占用和连接复用）
-    timeout: 3000, // socket超时3秒（高并发场景快速失败）
-    requestTimeout: 3000, // 请求超时3秒（快速释放资源，避免慢请求占用连接）
-    retries: 1, // 重试1次（减少重试，避免高并发时加重后端压力）
-    retryBaseDelay: 100, // 基础重试延迟100ms（给服务恢复时间）
-    logThreshold: 1000, // 日志采样率（每1000个请求采样1次，降低日志开销）
-    monitorInterval: 5000, // 监控日志间隔（毫秒）
+    maxSockets: 3000, // 每个 host 最大并发连接数
+    maxFreeSockets: 1000, // 保持空闲连接数（减少连接重建开销）
+    maxTotalSockets: 10000, // 所有 host 总连接数上限（支持多个服务同时调用）
+    keepAliveMsecs: 60000, // 保持连接60秒
+    timeout: 5000, // socket超时5秒
+    requestTimeout: 5000, // 请求超时5秒
+    retries: 0, // 不重试（失败直接返回）
+    retryBaseDelay: 200, // 基础重试延迟200ms
 };
 // 配置 HTTP/HTTPS Agent 以支持高并发连接池和 keepAlive
 const httpAgent = new http_1.default.Agent({
@@ -34,7 +29,7 @@ const httpAgent = new http_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo', // 先进先出调度
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 const httpsAgent = new https_1.default.Agent({
     keepAlive: true,
@@ -43,7 +38,7 @@ const httpsAgent = new https_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo',
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 // 配置 axios 默认使用这些 agent
 axios_1.default.defaults.httpAgent = httpAgent;
@@ -57,10 +52,16 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
     retryCondition(error) {
         // 重试临时错误和特定的网络错误
         const status = error.response?.status;
-        const isNetworkError = error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
+        const isNetworkError = error.code === 'ECONNRESET' ||
+            error.code === 'ETIMEDOUT' ||
+            error.code === 'ECONNREFUSED' ||
+            error.code === 'ENOTFOUND' ||
+            error.code === 'ENETUNREACH' ||
+            error.code === 'EAI_AGAIN';
         const isServerError = status === 502 || status === 503 || status === 504;
         const isRateLimited = status === 429;
-        return isNetworkError || isServerError || isRateLimited;
+        const isTimeout = error.code === 'ECONNABORTED' || error.message?.includes('timeout');
+        return isNetworkError || isServerError || isRateLimited || isTimeout;
     },
     retryDelay: (retryCount, error) => {
         // 指数退避 + 抖动
@@ -73,138 +74,35 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
             }
             return 1000 + Math.random() * 1000; // 1-2秒
         }
-        // 指数退避：100ms, 200ms, 400ms...
+        // 指数退避：200ms, 400ms, 800ms...
         const exponentialDelay = HTTP_CONFIG.retryBaseDelay * Math.pow(2, retryCount - 1);
-        const jitter = Math.random() * 50; // 0-50ms 抖动
-        return Math.min(exponentialDelay + jitter, 2000); // 最多延迟2秒
+        const jitter = Math.random() * 100; // 0-100ms 抖动
+        return Math.min(exponentialDelay + jitter, 3000); // 最多延迟3秒
     },
     shouldResetTimeout: true, // 重试时重置超时
 });
-// 连接池状态监控
-let requestCount = 0;
-let activeRequests = 0;
-let peakActiveRequests = 0; // 峰值并发
 async function callApi(url, request) {
-    // 不再等待应用层队列，直接发起请求，由底层socket连接池控制并发
-    const currentRequestId = ++requestCount;
-    activeRequests++;
-    // 记录峰值并发
-    if (activeRequests > peakActiveRequests) {
-        peakActiveRequests = activeRequests;
-    }
-    // 批量获取请求上下文，减少函数调用开销
+    // 获取请求上下文
     const ctx = request_context_1.requestContext.get('requestId') ? request_context_1.requestContext : null;
     const requestId = ctx?.get('requestId') || ctx?.get('traceMessageId') || (0, uuid_1.v4)();
     const pandoraUserId = ctx?.get('pandoraUserId') || '';
     const beLinkUserId = ctx?.get('beLinkUserId') || '';
     const pandoraRoleId = ctx?.get('pandoraRoleId') || '';
     const realIp = ctx?.get('realIp') || '';
-    // 采样日志决策（提前计算，避免重复判断）
-    const shouldLog = currentRequestId % HTTP_CONFIG.logThreshold === 0;
-    const startTime = shouldLog ? Date.now() : 0;
-    try {
-        if (shouldLog) {
-            console.log((0, safe_stable_stringify_1.default)({
-                message: '发起HTTP请求',
-                currentRequestId,
-                activeRequests,
-                requestId,
-                url,
-                type: 'http_request_start',
-            }));
-        }
-        const response = await axios_1.default.post(url, request || {}, {
-            headers: {
-                'x-request-id': requestId,
-                'x-belink-pandora-userid': pandoraUserId,
-                'x-belink-userid': beLinkUserId,
-                'x-belink-pandora-roleid': pandoraRoleId,
-                'x-real-ip': realIp,
-                Connection: 'keep-alive',
-            },
-            timeout: HTTP_CONFIG.requestTimeout,
-            httpAgent,
-            httpsAgent,
-        });
-        if (shouldLog) {
-            const duration = Date.now() - startTime;
-            if (duration > 3000) {
-                console.log((0, safe_stable_stringify_1.default)({
-                    message: '请求完成',
-                    currentRequestId,
-                    duration: `${duration}ms`,
-                    activeRequests,
-                    type: 'http_request_complete',
-                }));
-            }
-        }
-        const responseData = response.data;
-        return responseData.data;
-    }
-    catch (error) {
-        const axiosError = error;
-        const duration = startTime ? Date.now() - startTime : 0;
-        // 错误始终记录（但简化输出）
-        console.error((0, safe_stable_stringify_1.default)({
-            message: '请求失败',
-            currentRequestId,
-            url,
-            duration: `${duration}ms`,
-            activeRequests,
-            errorMessage: axiosError.message,
-            type: 'http_request_failed',
-        }));
-        if (axiosError.response) {
-            const response = axiosError.response;
-            const data = response.data;
-            console.error((0, safe_stable_stringify_1.default)({
-                message: '响应异常',
-                status: response.status,
-                errorMessage: data?.message || axiosError.message,
-                type: 'http_response_error',
-            }));
-        }
-        throw error;
-    }
-    finally {
-        // 记录请求完成，减少活跃计数
-        activeRequests--;
-    }
-}
-// 导出监控函数
-function getConnectionStats() {
-    const stats = {
-        // 当前状态
-        activeRequests,
-        totalRequests: requestCount,
-        // 峰值指标
-        peakActiveRequests,
-        // Socket连接池状态（这是真正的并发控制点）
-        httpSockets: {
-            total: Object.keys(httpAgent.sockets).reduce((sum, host) => sum + (httpAgent.sockets[host]?.length || 0), 0),
-            hosts: Object.keys(httpAgent.sockets).length,
-            details: httpAgent.sockets,
-        },
-        httpsSockets: {
-            total: Object.keys(httpsAgent.sockets).reduce((sum, host) => sum + (httpsAgent.sockets[host]?.length || 0), 0),
-            hosts: Object.keys(httpsAgent.sockets).length,
-            details: httpsAgent.sockets,
+    const response = await axios_1.default.post(url, request || {}, {
+        headers: {
+            'x-request-id': requestId,
+            'x-belink-pandora-userid': pandoraUserId,
+            'x-belink-userid': beLinkUserId,
+            'x-belink-pandora-roleid': pandoraRoleId,
+            'x-real-ip': realIp,
+            Connection: 'keep-alive',
+            'Content-Type': 'application/json;charset=utf-8',
         },
-        // 配置信息
-        config: {
-            maxSockets: HTTP_CONFIG.maxSockets,
-            maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
-            requestTimeout: HTTP_CONFIG.requestTimeout,
-            note: '已移除应用层并发队列限制，完全依赖socket连接池',
-        },
-    };
-    return stats;
-}
-// 重置峰值统计（可用于定期重置）
-function resetPeakStats() {
-    peakActiveRequests = activeRequests;
-    console.log((0, safe_stable_stringify_1.default)({
-        message: '峰值统计已重置',
-        type: 'stats_reset',
-    }));
+        timeout: HTTP_CONFIG.requestTimeout,
+        httpAgent,
+        httpsAgent,
+    });
+    const responseData = response.data;
+    return responseData.data;
 }