liufumingren c2a761ca26 feat(inbox): 新增开门/到货/进场/离场车牌登记与 extend_props 持久化
- functions 新增 openDoor/registerLicensePlate/enter/departure(规则表+权限分组)
- 到货登记表 wms_inbox_arrival_register(含消费字段,离场闭环,货主收货群优先推送)
- 回执 extend_props 持久化落库与定时补发送下发(重推兜底回读)
- 车牌提取正则兼容异体字(粤/粵)
- 售后类型/关键字/函数/回复 v2 模型与迁移
- INBOX V2 HTTP 测试报告与指南
2026-09-17 02:41:43 +08:00

1220 lines
42 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const MainService = require('../main');
const AFTER_SALE_EXPORT_TASK_CACHE_KEY_PREFIX = 'after_sale_export_task_';
const AFTER_SALE_EXPORT_TASK_CACHE_TTL_SECONDS = 1800;
/**
* 售后 block 权限 ID → role_group 映射表。
* 516=客服组, 517=仓库组, 518=财务组
*/
const BLOCK_PERMISSION_ROLE_GROUP_MAP = Object.freeze({
516: 'customer_service',
517: 'warehouse',
518: 'finance',
});
/**
* 售后模块工作列表排除的终态(已完成/已关闭/已取消)。
* pending_feedback 不在静态排除列表中,由 workList 根据 followup_at 动态判断。
*/
const WORK_LIST_EXCLUDED_STATUSES = Object.freeze([ 'completed', 'closed', 'cancelled' ]);
/**
* 系统方法层:afterSale(售后模块接口包装层)。
* 主要职责:统一包装系统方法接口,处理权限、日志、where 解析等公共逻辑,
* 将具体业务逻辑下沉到 systems.afterSale 中。
*/
class AfterSaleMethodService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'workList,auditList,detail,create,transfer,handleWorkOrder,batchSetPendingFeedback,batchClose,registerClaim,export,exportTaskProgress,workCount,typeList,typeCreate,typeUpdate,typeDelete,subTypeList,subTypeCreate,subTypeUpdate,subTypeDelete';
const _noNeedLog = 'workList,auditList,detail,export,exportTaskProgress,workCount,typeList,subTypeList';
const _noNeedAuth = 'workList,auditList,detail,create,transfer,handleWorkOrder,batchSetPendingFeedback,batchClose,registerClaim,export,exportTaskProgress,workCount,typeList,typeCreate,typeUpdate,typeDelete,subTypeList,subTypeCreate,subTypeUpdate,subTypeDelete';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
// ===========================
// 售后工作列表
// ===========================
/**
* 售后工作列表:按当前用户的 block 权限筛选可见的售后单。
* 解析用户 wms_role.permissions 中 type=block 的售后权限 ID(516/517/518),
* 映射为 role_group,仅展示当前用户可处理的售后单。
*
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.where] 动态筛选条件
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装
*/
async workList(data = {}) {
const { service } = this;
const { pagination, sort } = data;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
// 提取当前用户的售后 block 权限 → role_group 列表
const allowedRoleGroups = await this._resolveAfterSaleBlockRoleGroups();
// 强制过滤:仅展示当前用户可处理的 role_group,且排除已完成/已取消
const enforcedWhere = {
...where,
role_group: {
operator: 'in',
value: allowedRoleGroups,
},
status: {
operator: 'notin',
value: WORK_LIST_EXCLUDED_STATUSES,
},
};
const result = await service.systems.afterSale.list(enforcedWhere, pagination, sort, {
order: [[ 'priority', 'DESC' ], [ 'updated_at', 'DESC' ]],
excludeFutureFollowup: true,
// 列表行补充货主名称 store_name(合约表 store_remask 货主备注,无备注时回退货主公司全称)
enrichStoreName: true,
});
return this.success('ok', result);
}
/**
* 解析当前用户所拥有的售后 block 权限对应的 role_group 列表。
* 从 wms_role.permissions 中查询当前激活角色的原始权限 ID,
* 若 permissions='*' 则返回全部 role_group,否则筛选 516/517/518。
*
* @return {Promise<string[]>} 当前用户可处理的 role_group 列表
*/
async _resolveAfterSaleBlockRoleGroups() {
const { ctx } = this;
const employeeId = ctx.user && ctx.user.employees_id;
if (!employeeId) {
return [ '__none__' ];
}
try {
// 1. 通过 EmployeeRole 找到 role_id
const employeeRole = await ctx.model.EmployeeRole.findOne({
where: { employee_id: employeeId },
attributes: [ 'role_id' ],
raw: true,
});
if (!employeeRole || !employeeRole.role_id) {
return [ '__none__' ];
}
// 2. 读取 wms_role.permissions
const role = await ctx.model.Role.findOne({
where: { id: employeeRole.role_id, status: 1 },
attributes: [ 'permissions' ],
raw: true,
});
if (!role) {
return [ '__none__' ];
}
// 3. 标准化解析
const state = ctx.service.systems.auth.rolePermission.normalizePermissionSet(role.permissions);
// 超级管理员 → 全部 role_group
if (state.allAccess) {
return [ 'customer_service', 'warehouse', 'finance' ];
}
// 匹配 block 权限 516/517/518
const allowedRoleGroups = [];
for (const permId of state.permissionIds) {
if (BLOCK_PERMISSION_ROLE_GROUP_MAP[permId]) {
allowedRoleGroups.push(BLOCK_PERMISSION_ROLE_GROUP_MAP[permId]);
}
}
if (allowedRoleGroups.length === 0) {
return [ '__none__' ];
}
return allowedRoleGroups;
} catch (err) {
ctx.logger.warn(`[_resolveAfterSaleBlockRoleGroups] 权限查询失败: ${err.message}`);
return [ '__none__' ];
}
}
// ===========================
// 待处理工单计数(角标用)
// ===========================
/**
* 快速查询当前用户待处理售后工单数量(用于角标显示)。
* 过滤逻辑与 workList 一致:role_group 按 block 权限,排除已完成/已取消。
* 返回 { count: number },前端自行判断 >99 显示 99+。
*
* @param {Object} data 请求体(可选 where 条件)
* @return {Promise<Object>} { count: number }
*/
async workCount(data = {}) {
const { service } = this;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
// 与 workList 一致的角色组 + 状态过滤
const allowedRoleGroups = await this._resolveAfterSaleBlockRoleGroups();
const enforcedWhere = {
...where,
role_group: {
operator: 'in',
value: allowedRoleGroups,
},
status: {
operator: 'notin',
value: WORK_LIST_EXCLUDED_STATUSES,
},
};
const result = await service.systems.afterSale.countPending(enforcedWhere, { excludeFutureFollowup: true });
return this.success('ok', { count: result.count });
}
// ===========================
// 售后审计列表
// ===========================
/**
* 售后审计列表:不限 role_group 与 status(包含已完成/已取消)。
* 用于管理员/审计角色查看全部售后单。
*
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.where] 动态筛选条件
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装
*/
async auditList(data = {}) {
const { service } = this;
const { pagination, sort } = data;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const result = await service.systems.afterSale.list(where, pagination, sort);
return this.success('ok', result);
}
// ===========================
// 售后明细
// ===========================
/**
* 售后明细:查询主表、步骤列表及步骤附件。
*
* @param {Object} data 请求体
* @param {number} data.id 售后单主键ID
* @return {Promise<Object>} 统一 success 包装,包含主表、步骤列表及附件信息
*/
async detail(data = {}) {
const { service } = this;
const { id } = data || {};
if (!id) {
return this.fail('缺少售后单ID');
}
const result = await service.systems.afterSale.getDetail(Number(id));
return this.success('ok', result);
}
// ===========================
// 创建售后单
// ===========================
/**
* 创建售后单:生成售后单号,写入主表记录。
* warehouse_id 由服务端从当前上下文自动注入。
*
* @param {Object} data 请求体
* @param {string} data.type 售后类型(order/receiving/entry/stockout)
* @param {string} data.sub_type 售后子类型
* @param {string} data.title 售后标题
* @param {string} [data.description] 售后详细描述
* @param {number} [data.priority=0] 优先级
* @param {number} [data.waybill_id] 关联运单ID
* @param {number} [data.order_delivery_id] 关联发货订单ID(兼容别名 order_id)
* @param {number} [data.entry_order_id] 关联入库单ID
* @param {number} [data.order_stockout_id] 关联出库单ID
* @param {number} [data.receiving_id] 关联收货单ID
* @param {number} [data.store_id] 关联货主ID
* @param {number} [data.inbox_message_id] 关联站内信ID
* @return {Promise<Object>} 统一 success 包装,返回新创建的售后单信息
*/
async create(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const creatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
if (!warehouseId) {
return this.fail('无法获取当前仓库上下文');
}
const {
type,
sub_type: subType,
title,
description,
priority,
waybill_id: waybillId,
order_delivery_id: orderDeliveryIdRaw,
order_id: orderIdRaw,
entry_order_id: entryOrderId,
order_stockout_id: orderStockoutId,
receiving_id: receivingId,
store_id: storeId,
inbox_message_id: inboxMessageId,
} = data || {};
// 兼容 order_id 别名(优先 order_delivery_id,为空时取 order_id)
const orderDeliveryId = orderDeliveryIdRaw || orderIdRaw || null;
// 生成售后单号
const afterSaleNo = await this.generateAfterSaleNo(warehouseId);
// 处理单据关联字段的冗余同步(waybill_no 等从对应表同步取数)
const redundantFields = await this._resolveRedundantFields({
waybillId,
orderDeliveryId,
entryOrderId,
orderStockoutId,
receivingId,
});
const createData = {
warehouse_id: warehouseId,
after_sale_no: afterSaleNo,
type,
sub_type: subType,
title,
description: description || null,
priority: priority !== undefined ? Number(priority) : 0,
creator_id: creatorId,
role_group: 'customer_service',
status: 'pending',
waybill_id: waybillId || null,
waybill_no: redundantFields.waybill_no || null,
order_id: orderDeliveryId || null,
order_no: redundantFields.order_no || null,
entry_order_id: entryOrderId || null,
entry_order_no: redundantFields.entry_order_no || null,
order_stockout_id: orderStockoutId || null,
order_stockout_no: redundantFields.order_stockout_no || null,
receiving_id: receivingId || null,
receiving_no: redundantFields.receiving_no || null,
store_id: storeId || null,
inbox_message_id: inboxMessageId || null,
};
const result = await service.systems.afterSale.create(createData);
return this.success('售后单创建成功', result);
}
/**
* 解析单据关联字段的冗余值(waybill_no、order_delivery_no 等),
* 从对应的关联表中同步取数。
*
* @param {Object} params 关联ID集合
* @param {number} [params.waybillId] 运单ID
* @param {number} [params.orderDeliveryId] 发货订单ID
* @param {number} [params.entryOrderId] 入库单ID
* @param {number} [params.orderStockoutId] 出库单ID
* @param {number} [params.receivingId] 收货单ID
* @return {Promise<Object>} 冗余字段键值对
*/
async _resolveRedundantFields(params = {}) {
const { ctx } = this;
const redundant = {};
// 运单号
if (params.waybillId) {
try {
const waybill = await ctx.model.OrderExpress.findOne({
where: { id: params.waybillId },
attributes: [ 'waybill_code' ],
raw: true,
});
redundant.waybill_no = waybill ? waybill.waybill_code || null : null;
} catch (err) {
ctx.logger.warn(`[afterSale._resolveRedundantFields] 查询运单号失败: ${err.message}`);
}
}
// 发货订单号
if (params.orderDeliveryId) {
try {
const warehouseId = ctx.user && ctx.user.store_id;
const DeliveryModel = warehouseId
? await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId)
: null;
if (DeliveryModel) {
const order = await DeliveryModel.findOne({
where: { id: params.orderDeliveryId },
attributes: [ 'delivery_order_code' ],
raw: true,
});
redundant.order_no = order ? order.delivery_order_code || null : null;
}
} catch (err) {
ctx.logger.warn(`[afterSale._resolveRedundantFields] 查询发货订单号失败: ${err.message}`);
}
}
// 入库单号
if (params.entryOrderId) {
try {
const entry = await ctx.model.EntryOrder.findOne({
where: { id: params.entryOrderId },
attributes: [ 'entry_order_code' ],
raw: true,
});
redundant.entry_order_no = entry ? entry.entry_order_code || null : null;
} catch (err) {
ctx.logger.warn(`[afterSale._resolveRedundantFields] 查询入库单号失败: ${err.message}`);
}
}
// 出库单号
if (params.orderStockoutId) {
try {
const stockout = await ctx.model.OrderStockout.findOne({
where: { id: params.orderStockoutId },
attributes: [ 'order_stockout_no' ],
raw: true,
});
redundant.order_stockout_no = stockout ? stockout.order_stockout_no || null : null;
} catch (err) {
ctx.logger.warn(`[afterSale._resolveRedundantFields] 查询出库单号失败: ${err.message}`);
}
}
// 收货单号
if (params.receivingId) {
try {
const receiving = await ctx.model.Receiving.findOne({
where: { id: params.receivingId },
attributes: [ 'receiving_code' ],
raw: true,
});
redundant.receiving_no = receiving ? receiving.receiving_code || null : null;
} catch (err) {
ctx.logger.warn(`[afterSale._resolveRedundantFields] 查询收货单号失败: ${err.message}`);
}
}
return redundant;
}
// ===========================
// 转单
// ===========================
/**
* 转单:将售后单的 role_group 更新为目标值,并写入一条 detail 步骤记录。
*
* @param {Object} data 请求体
* @param {number} data.id 售后单主键ID
* @param {string} data.role_group 目标角色组(customer_service/warehouse/finance)
* @param {string} [data.remark] 转单备注
* @return {Promise<Object>} 统一 success 包装
*/
async transfer(data = {}) {
const { ctx, service } = this;
const {
id,
role_group: targetRoleGroup,
remark,
} = data || {};
if (!id) {
return this.fail('缺少售后单ID');
}
if (!targetRoleGroup) {
return this.fail('缺少目标角色组');
}
const operatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
const operatorSnapshot = this._buildOperatorSnapshot();
const result = await service.systems.afterSale.transfer({
id: Number(id),
targetRoleGroup,
remark: remark || '',
operatorId,
operatorSnapshot,
});
return this.success('转单成功', result);
}
// ===========================
// 处理工单
// ===========================
/**
* 处理工单:校验权限后写入步骤记录,可选更新状态与附件。
* 若处理完后当前 role_group 非客服组且状态未完结,自动回设为客服组。
*
* @param {Object} data 请求体
* @param {number} data.id 售后单主键ID
* @param {string} [data.remark] 处理备注
* @param {string} [data.status] 目标售后状态
* @param {string} [data.resolution] 完结处理结果(status=completed 时写入)
* @param {number[]} [data.attachment_ids] 附件文件ID列表
* @return {Promise<Object>} 统一 success 包装
*/
async handleWorkOrder(data = {}) {
const { ctx, service } = this;
const {
id,
remark,
status: targetStatus,
resolution,
attachment_ids: attachmentIds,
} = data || {};
if (!id) {
return this.fail('缺少售后单ID');
}
// status 不填或填错默认 processing;pending 是创建默认值,不适用于处理操作
const ALLOWED_STATUSES = Object.keys(ctx.model.AfterSale.AFTER_SALE_STATUS).filter(s => s !== 'pending');
const safeStatus = (targetStatus && ALLOWED_STATUSES.includes(targetStatus)) ? targetStatus : 'processing';
const operatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
const operatorSnapshot = this._buildOperatorSnapshot();
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const result = await service.systems.afterSale.handleWorkOrder({
id: Number(id),
remark: remark || null,
targetStatus: safeStatus,
resolution: resolution || null,
attachmentIds: Array.isArray(attachmentIds) ? attachmentIds : [],
operatorId,
operatorSnapshot,
warehouseId,
notifyGroup: true,
});
return this.success('处理成功', result);
}
// ===========================
// 批量设为待反馈
// ===========================
/**
* 批量将售后工单设为"待反馈"状态,按仓库配置自动计算下次跟进时间。
* 所有工单在同一事务中处理,任一失败则全部回滚。
*
* @param {Object} data 请求体
* @param {number[]} data.ids 售后单主键ID列表
* @param {string} [data.remark] 统一处理备注(所有工单共用)
* @return {Promise<Object>} 统一 success 包装,包含 total/success/failed
*/
async batchSetPendingFeedback(data = {}) {
const { ctx, service } = this;
const { ids, remark } = data || {};
if (!Array.isArray(ids) || ids.length === 0) {
return this.fail('ids 不能为空且必须为数组');
}
const operatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
const operatorSnapshot = this._buildOperatorSnapshot();
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
if (!warehouseId) {
return this.fail('无法获取当前仓库上下文');
}
const result = await service.systems.afterSale.batchSetPendingFeedback({
ids,
remark: remark || null,
operatorId,
operatorSnapshot,
warehouseId,
});
return this.success('批量设为待反馈完成', result);
}
// ===========================
// 批量完结/关闭
// ===========================
/**
* 批量将售后工单设为完结或关闭状态。
* completed 时自动写入 resolved_at 并清除 followup_at。
* 所有工单在同一事务中处理,任一失败则全部回滚。
*
* @param {Object} data 请求体
* @param {number[]} data.ids 售后单主键ID列表
* @param {string} data.status 目标状态:completed | closed
* @param {string} [data.resolution] 完结处理结果(仅 status=completed 时写入)
* @param {string} [data.remark] 统一处理备注(所有工单共用)
* @return {Promise<Object>} 统一 success 包装,包含 total/success/failed
*/
async batchClose(data = {}) {
const { ctx, service } = this;
const { ids, status: targetStatus, resolution, remark } = data || {};
if (!Array.isArray(ids) || ids.length === 0) {
return this.fail('ids 不能为空且必须为数组');
}
const ALLOWED_TARGET_STATUSES = new Set([ 'completed', 'closed' ]);
if (!targetStatus || !ALLOWED_TARGET_STATUSES.has(targetStatus)) {
return this.fail('status 必须为 completed 或 closed');
}
const operatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
const operatorSnapshot = this._buildOperatorSnapshot();
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
if (!warehouseId) {
return this.fail('无法获取当前仓库上下文');
}
const result = await service.systems.afterSale.batchClose({
ids,
status: targetStatus,
resolution: resolution || null,
remark: remark || null,
operatorId,
operatorSnapshot,
warehouseId,
});
return this.success('批量操作完成', result);
}
// ===========================
// 登记理赔
// ===========================
/**
* 登记理赔:更新售后单的理赔相关字段,写入步骤记录,绑定附件。
*
* @param {Object} data 请求体
* @param {number} data.id 售后单主键ID
* @param {number} [data.claim_needed] 仓库理赔标记(0/1)
* @param {number} [data.claim_amount] 仓库理赔金额
* @param {string} [data.claim_status] 仓库理赔状态
* @param {number} [data.carrier_claim_needed] 运方理赔标记(0/1)
* @param {number} [data.carrier_claim_amount] 运方理赔金额
* @param {string} [data.carrier_claim_status] 运方理赔状态
* @param {string} [data.remark] 理赔备注
* @param {string} [data.action] 操作动作描述,默认"登记理赔"
* @param {number[]} [data.attachment_ids] 附件文件ID列表
* @return {Promise<Object>} 统一 success 包装
*/
async registerClaim(data = {}) {
const { ctx, service } = this;
const {
id,
claim_needed: claimNeeded,
claim_amount: claimAmount,
claim_status: claimStatus,
carrier_claim_needed: carrierClaimNeeded,
carrier_claim_amount: carrierClaimAmount,
carrier_claim_status: carrierClaimStatus,
remark,
action,
attachment_ids: attachmentIds,
} = data || {};
if (!id) {
return this.fail('缺少售后单ID');
}
const operatorId = ctx.user ? (ctx.user.id || ctx.user.user_id || 0) : 0;
const operatorSnapshot = this._buildOperatorSnapshot();
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const result = await service.systems.afterSale.registerClaim({
id: Number(id),
claimNeeded: claimNeeded !== undefined ? Number(claimNeeded) : undefined,
claimAmount: claimAmount !== undefined ? Number(claimAmount) : undefined,
claimStatus: claimStatus || undefined,
carrierClaimNeeded: carrierClaimNeeded !== undefined ? Number(carrierClaimNeeded) : undefined,
carrierClaimAmount: carrierClaimAmount !== undefined ? Number(carrierClaimAmount) : undefined,
carrierClaimStatus: carrierClaimStatus || undefined,
remark: remark || null,
action: action || '登记理赔',
attachmentIds: Array.isArray(attachmentIds) ? attachmentIds : [],
operatorId,
operatorSnapshot,
warehouseId,
});
return this.success('理赔登记成功', result);
}
// ===========================
// 导出
// ===========================
/**
* 提交售后单导出任务。
* 异步执行:分页查询 → ExcelJS 流式写入 → COS 上传。
* 进度通过 Redis 缓存追踪。
*
* @param {Object} data 请求体
* @param {Object} [data.where] 筛选条件(与列表一致)
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装,返回任务ID
*/
async export(data = {}) {
const { service } = this;
const { where, sort } = data || {};
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
current_count: 0,
total_count: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 5,
current_count: 0,
total_count: 0,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.afterSale.exportAfterSales({
where: this.isPlainObject(where) ? { ...where } : {},
sort: this.isPlainObject(sort) ? { ...sort } : {},
onProgress: async progress => {
const safeProgress = this.isPlainObject(progress) ? progress : {};
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: safeProgress.status || 'running',
progress: safeProgress.progress,
current_count: safeProgress.currentCount || 0,
total_count: safeProgress.totalCount || 0,
message: safeProgress.message || '导出任务执行中',
result: safeProgress.result || null,
error: '',
});
},
});
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'success',
progress: 100,
current_count: result.current_count || 0,
total_count: result.total_count || 0,
message: '导出任务完成',
result,
error: '',
});
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'failed',
progress: 100,
current_count: 0,
total_count: 0,
message: '导出任务失败',
result: null,
error: errorMessage,
});
}
});
return this.success('ok', {
...taskPayload,
update_time: Date.now(),
});
}
/**
* 查询售后单导出任务进度。
*
* @param {Object} data 请求体
* @param {string} [data.task_id] 任务ID(下划线写法)
* @param {string} [data.taskId] 任务ID(驼峰写法)
* @return {Promise<Object>} 统一 success 包装,包含进度与下载链接
*/
async exportTaskProgress(data = {}) {
const taskId = this.normalizeExportTaskId(data);
if (!taskId) {
return this.success('ok', {
task_id: '',
status: 'not_found',
progress: 0,
current_count: 0,
total_count: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const cachedTask = await this.getExportTaskProgress(taskId);
if (!cachedTask) {
return this.success('ok', {
task_id: taskId,
status: 'not_found',
progress: 0,
current_count: 0,
total_count: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const safeResult = this.isPlainObject(cachedTask.result) ? cachedTask.result : {};
const downloadUrl = String(
safeResult.url
|| safeResult.cdnUrl
|| safeResult.cosUrl
|| safeResult.fileKey
|| ''
);
return this.success('ok', {
task_id: taskId,
...cachedTask,
download_url: downloadUrl,
});
}
// ===========================
// 辅助方法
// ===========================
/**
* 生成售后单号。
* 格式:AS + YYYYMMDD + 6位序号(如 AS20240809000001)。
*
* @param {number} warehouseId 仓库ID
* @return {Promise<string>} 售后单号
*/
async generateAfterSaleNo(warehouseId) {
const { ctx } = this;
const datePart = this._getCurrentDatePart();
const prefix = 'AS';
const sql = `
SELECT after_sale_no
FROM wms_after_sale
WHERE warehouse_id = :warehouseId
AND after_sale_no LIKE :pattern
ORDER BY after_sale_no DESC
LIMIT 1
`;
const pattern = `${prefix}${datePart}%`;
const rows = await ctx.model.query(sql, {
replacements: { warehouseId, pattern },
type: ctx.model.QueryTypes.SELECT,
});
const latestNo = String(rows && rows[0] && rows[0].after_sale_no || '').trim();
let sequence = 1;
if (latestNo) {
const match = latestNo.match(/(\d{6})$/);
const lastSequence = match ? Number(match[1]) : 0;
if (Number.isInteger(lastSequence) && lastSequence > 0) {
sequence = lastSequence + 1;
}
}
return `${prefix}${datePart}${String(sequence).padStart(6, '0')}`;
}
/**
* 获取当前日期片段(YYYYMMDD)。
*
* @return {string} 当前日期片段
*/
_getCurrentDatePart() {
const now = new Date();
const year = now.getFullYear();
const month = String(now.getMonth() + 1).padStart(2, '0');
const day = String(now.getDate()).padStart(2, '0');
return `${year}${month}${day}`;
}
/**
* 构建操作人快照 JSON 字符串。
* 从 ctx.user 中提取关键身份信息。
*
* @return {string} 操作人快照 JSON
*/
_buildOperatorSnapshot() {
const { ctx } = this;
const user = ctx.user && typeof ctx.user === 'object' ? ctx.user : {};
const snapshot = {
id: user.id || user.user_id || null,
name: user.employees_name || user.real_name || user.name || '',
role: user.role && user.role.name ? user.role.name : '',
};
return JSON.stringify(snapshot);
}
/**
* 生成导出任务ID。
*
* @return {string} 导出任务ID
*/
generateExportTaskId() {
const warehouseId = this.ctx && this.ctx.user && this.ctx.user.store_id
? this.ctx.user.store_id
: 'unknown';
const timestamp = Date.now();
const randomToken = Math.random().toString(36).slice(2, 10);
return `after_sale_export_${warehouseId}_${timestamp}_${randomToken}`;
}
/**
* 归一化导出任务ID(兼容 task_id / taskId)。
*
* @param {Object} data 请求体
* @param {string} [data.task_id] 任务ID(下划线写法)
* @param {string} [data.taskId] 任务ID(驼峰写法)
* @return {string} 归一化后的任务ID
*/
normalizeExportTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 获取导出任务缓存键。
*
* @param {string} taskId 任务ID
* @return {string} 缓存键
*/
getExportTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${AFTER_SALE_EXPORT_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入导出任务进度缓存。
*
* @param {string} taskId 任务ID
* @param {Object} payload 任务状态载荷
* @return {Promise<void>} 无返回值
*/
async setExportTaskProgress(taskId = '', payload = {}) {
const cacheKey = this.getExportTaskCacheKey(taskId);
if (!cacheKey || typeof this.app.setCacheAsync !== 'function') {
return;
}
const safePayload = this.isPlainObject(payload) ? payload : {};
const normalizeCount = value => {
const numericValue = Number(value);
return Number.isFinite(numericValue) && numericValue >= 0 ? Math.round(numericValue) : 0;
};
const progressPayload = {
task_id: String(taskId || '').trim(),
status: String(safePayload.status || 'submitted').trim() || 'submitted',
progress: Number.isFinite(Number(safePayload.progress))
? Math.min(100, Math.max(0, Math.round(Number(safePayload.progress))))
: 0,
current_count: normalizeCount(safePayload.current_count),
total_count: normalizeCount(safePayload.total_count),
message: String(safePayload.message || ''),
result: safePayload.result ?? null,
error: String(safePayload.error || ''),
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(
cacheKey,
progressPayload,
AFTER_SALE_EXPORT_TASK_CACHE_TTL_SECONDS
);
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
this.ctx.logger.warn(`[afterSale.export] 写入导出任务缓存失败: ${errorMessage}`);
}
}
/**
* 读取导出任务进度缓存。
*
* @param {string} taskId 任务ID
* @return {Promise<Object|null>} 任务缓存,不存在则返回 null
*/
async getExportTaskProgress(taskId = '') {
const cacheKey = this.getExportTaskCacheKey(taskId);
if (!cacheKey || typeof this.app.getCacheAsync !== 'function') {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
this.ctx.logger.warn(`[afterSale.export] 读取导出任务缓存失败: ${errorMessage}`);
return null;
}
}
// ===========================
// 售后类型/子类型自定义配置
// ===========================
/**
* 售后类型列表:返回系统级(warehouse_id IS NULL)+ 当前仓库自定义的合并列表。
* 默认按 sort_order 升序、id 升序;支持分页、where 条件({operator, value} 规范)与排序。
*
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {number} [data.pagination.page=1] 页码
* @param {number} [data.pagination.pageSize=20] 每页数量(上限500)
* @param {Object} [data.where] 筛选条件,支持字段 id/type/name/is_system/is_enabled/sort_order/created_at/updated_at
* @param {Object} [data.sort] 排序参数 { sortField, sortOrder },不传时默认 sort_order ASC, id ASC
* @return {Promise<Object>} 统一 success 包装,data 为 { list, pagination }
*/
async typeList(data = {}) {
const { ctx, service } = this;
const { pagination, sort } = data || {};
const { where } = this.prepareWhereContext(data);
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const result = await service.systems.afterSale.getTypeList({ warehouseId, where, pagination, sort });
return this.success('ok', result);
}
/**
* 创建仓库自定义售后类型。warehouse_id 由服务端从当前上下文自动注入,前端无需传递。
*
* @param {Object} data 请求体
* @param {string} data.type 类型编码(仅小写字母/数字/下划线,不可与系统级编码重复)
* @param {string} data.name 类型名称(长度≤50)
* @param {number} [data.sort_order=0] 排序值
* @param {number} [data.is_enabled=1] 是否启用(0/1)
* @return {Promise<Object>} 成功返回 success 包装及新记录;失败返回 fail 包装(含业务码)
*/
async typeCreate(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const {
type,
name,
sort_order: sortOrder,
is_enabled: isEnabled,
} = data || {};
try {
const result = await service.systems.afterSale.createType({ warehouseId, type, name, sortOrder, isEnabled });
return this.success('售后类型创建成功', result);
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
/**
* 更新仓库自定义售后类型。仅允许修改 name/is_enabled/sort_order,type 编码不可变。
*
* @param {Object} data 请求体
* @param {number} data.id 类型主键ID
* @param {string} [data.name] 类型名称(长度≤50)
* @param {number} [data.is_enabled] 是否启用(0/1)
* @param {number} [data.sort_order] 排序值
* @return {Promise<Object>} 成功返回 success 包装及更新后记录;失败返回 fail 包装(含业务码)
*/
async typeUpdate(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const {
id,
name,
sort_order: sortOrder,
is_enabled: isEnabled,
} = data || {};
try {
const result = await service.systems.afterSale.updateType({ warehouseId, id, name, sortOrder, isEnabled });
return this.success('售后类型更新成功', result);
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
/**
* 删除仓库自定义售后类型。系统级类型禁止删除;
* 删除前检查该类型下是否存在当前仓库的自定义子类型,存在则拒绝(需先删除子类型)。
*
* @param {Object} data 请求体
* @param {number} data.id 类型主键ID
* @return {Promise<Object>} 成功返回 success 包装;失败返回 fail 包装(含业务码)
*/
async typeDelete(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const { id } = data || {};
try {
const result = await service.systems.afterSale.deleteType({ warehouseId, id });
return this.success('售后类型删除成功', { data: result });
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
/**
* 售后子类型列表:返回系统级 + 当前仓库自定义的合并列表,支持按 type 过滤与按 type 分组返回。
* 默认按 sort_order 升序、id 升序。
*
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {number} [data.pagination.page=1] 页码
* @param {number} [data.pagination.pageSize=20] 每页数量(上限500)
* @param {Object} [data.where] 筛选条件,支持字段 id/type/sub_type/name/is_system/is_enabled/sort_order/created_at/updated_at
* @param {Object} [data.sort] 排序参数 { sortField, sortOrder },不传时默认 sort_order ASC, id ASC
* @param {boolean} [data.group] 是否按 type 分组返回 groups(true 时额外返回 groups 数组)
* @return {Promise<Object>} 统一 success 包装,data 为 { list, pagination, groups? }
*/
async subTypeList(data = {}) {
const { ctx, service } = this;
const { pagination, sort, group } = data || {};
const { where } = this.prepareWhereContext(data);
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const result = await service.systems.afterSale.getSubTypeList({ warehouseId, where, pagination, sort, group });
return this.success('ok', result);
}
/**
* 创建仓库自定义售后子类型。warehouse_id 由服务端从当前上下文自动注入,前端无需传递。
* 所属类型必须存在(系统级或当前仓库自定义)且处于启用状态。
*
* @param {Object} data 请求体
* @param {string} data.type 所属类型编码(必须已存在且启用)
* @param {string} data.sub_type 子类型编码(仅小写字母/数字/下划线,不可与系统级同 type 下编码重复)
* @param {string} data.name 子类型名称(长度≤50)
* @param {number} [data.sort_order=0] 排序值
* @param {number} [data.is_enabled=1] 是否启用(0/1)
* @return {Promise<Object>} 成功返回 success 包装及新记录;失败返回 fail 包装(含业务码)
*/
async subTypeCreate(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const {
type,
sub_type: subType,
name,
sort_order: sortOrder,
is_enabled: isEnabled,
} = data || {};
try {
const result = await service.systems.afterSale.createSubType({ warehouseId, type, subType, name, sortOrder, isEnabled });
return this.success('售后子类型创建成功', result);
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
/**
* 更新仓库自定义售后子类型。仅允许修改 name/is_enabled/sort_order,type 与 sub_type 编码不可变。
*
* @param {Object} data 请求体
* @param {number} data.id 子类型主键ID
* @param {string} [data.name] 子类型名称(长度≤50)
* @param {number} [data.is_enabled] 是否启用(0/1)
* @param {number} [data.sort_order] 排序值
* @return {Promise<Object>} 成功返回 success 包装及更新后记录;失败返回 fail 包装(含业务码)
*/
async subTypeUpdate(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const {
id,
name,
sort_order: sortOrder,
is_enabled: isEnabled,
} = data || {};
try {
const result = await service.systems.afterSale.updateSubType({ warehouseId, id, name, sortOrder, isEnabled });
return this.success('售后子类型更新成功', result);
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
/**
* 删除仓库自定义售后子类型。系统级子类型禁止删除;
* 若该子类型已被当前仓库的售后单使用(wms_after_sale 存在引用),拒绝删除。
*
* @param {Object} data 请求体
* @param {number} data.id 子类型主键ID
* @return {Promise<Object>} 成功返回 success 包装;失败返回 fail 包装(含业务码)
*/
async subTypeDelete(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user && ctx.user.store_id ? Number(ctx.user.store_id) : 0;
const { id } = data || {};
try {
const result = await service.systems.afterSale.deleteSubType({ warehouseId, id });
return this.success('售后子类型删除成功', { data: result });
} catch (e) {
return this.fail(e.message, { code: Number(e.code) || 400 });
}
}
}
module.exports = AfterSaleMethodService;