liufumingren 95067aeb8a feat(wms): 工作台成员、波次范围、库存明细与报表修复等多项更新
- workbench: 工作台成员拆分 wms_workbench_member 表,下线 barcode 字段,新增绑定/移除成员接口

- order: 订单配送新增 wave_scope 波次范围字段与历史回填,自动分配快递排除备注与储位分配限制修复

- storage.transaction.list: 重写为 wms_storage_transaction 逐条明细查询,消除聚合慢查询

- stock.report: 分页默认生效、排序白名单扩充、where.stock_id 数组兼容修复

- storage.entry: quickInbound/commit 新增 noNeedNotice 通知开关

- storage.inventory.list: stock_query 支持数组多关键字并集匹配

- store: 手工单回传通知策略 notify_manual_sync

- docs: 同步接口文档与变更记录、路由表;test: 补充快递排除与储位分配限制测试
2026-09-05 22:43:38 +08:00

318 lines
10 KiB
JavaScript
Raw Permalink 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 STORAGE_TRANSACTION_EXPORT_TASK_CACHE_KEY_PREFIX = 'storage_transaction_export_task_';
const STORAGE_TRANSACTION_EXPORT_TASK_CACHE_TTL_SECONDS = 1800;
class StorageTransactionService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'list,export,exportTaskProgress';
const _noNeedLog = 'list,export,exportTaskProgress';
const _noNeedAuth = 'list,export,exportTaskProgress';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 解析 list/export 通用过滤入参(where 白名单字段 + 时间区间 + keyword)。
* @param {Object} data 请求体
* @return {Object} 归一化后的过滤参数
*/
_parseListFilters(data = {}) {
const { whereValue = {} } = this.prepareWhereContext(data);
const { keyword: topKeyword } = data;
const {
transaction_type: transactionType,
stock_id: stockIdRaw,
stock_ids: stockIdsRaw,
space_id: spaceId,
store_id: storeIdRaw,
store_ids: storeIdsRaw,
order_type: orderType,
order_no: orderNo,
batch_no: batchNo,
inventory_type: inventoryType,
operator_name: operatorName,
order_id: orderId,
start_time: startTime,
end_time: endTime,
created_at: createdAt,
keyword: whereKeyword,
} = whereValue;
// created_at 支持 between:规范化后 value 为 [start, end] 数组
const createdRange = Array.isArray(createdAt) ? createdAt : [];
const resolvedStartTime = startTime ?? createdRange[0] ?? null;
const resolvedEndTime = endTime ?? createdRange[1] ?? null;
// 兼容 stock_id(单数)与 stock_ids(数组),store_id 同理
const stockIds = stockIdsRaw !== undefined
? stockIdsRaw
: (stockIdRaw !== undefined ? [ stockIdRaw ] : null);
const storeIds = storeIdsRaw !== undefined
? storeIdsRaw
: (storeIdRaw !== undefined ? [ storeIdRaw ] : null);
const keyword = topKeyword ?? whereKeyword ?? '';
// 仓库ID 由服务端从当前上下文注入,禁止前端传参
const warehouseId = Number(this.ctx.user && this.ctx.user.store_id);
return {
warehouseId,
startTime: resolvedStartTime,
endTime: resolvedEndTime,
storeIds,
stockIds,
spaceId,
keyword,
transactionType,
orderType,
orderNo,
batchNo,
inventoryType,
operatorName,
orderId,
};
}
/**
* 库位维度出入库流水逐条明细列表(wms_storage_transaction)。
* 支持 where 条件、keyword 快捷搜索、分页、排序;仓库ID由服务端从当前上下文自动注入。
* group_by_batch 参数已废弃:本接口不再聚合,恒返回逐条明细。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.where.created_at] 创建时间区间(operator: between,value: [start, end])
* @param {Object} [data.pagination] 分页参数 { page, pageSize }
* @param {Object} [data.sort] 排序参数 { sortField, sortOrder }
* @param {string} [data.keyword] 商品关键字(按 item_code/item_name/goods_code/barcode 模糊匹配)
* @return {Promise<Object>} 统一 success 包装
*/
async list(data = {}) {
const { service } = this;
const { pagination = {}, sort = {} } = data;
const filters = this._parseListFilters(data);
const result = await service.systems.stockTransaction.list({
...filters,
sort,
pagination,
});
return this.success('ok', result);
}
/**
* 提交库位流水导出异步任务。
* 与 list 使用相同查询条件(where/sort/keyword),异步执行,立即返回任务ID。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件(与 list 完全一致)
* @param {Object} [data.sort] 排序参数(与 list 完全一致)
* @param {string} [data.keyword] 商品关键字(与 list 完全一致)
* @return {Promise<Object>} 统一 success 包装(返回任务ID)
*/
async export(data = {}) {
const { service } = this;
const { sort = {} } = data;
const filters = this._parseListFilters(data);
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 10,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.stockTransaction.exportStorageList({
...filters,
sort,
});
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'success',
progress: 100,
message: '导出任务完成',
result,
error: '',
});
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'failed',
progress: 100,
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,
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,
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,
});
}
/**
* 生成库位流水导出任务ID。
* @return {string} 导出任务ID
*/
generateExportTaskId() {
const warehouseId = this.ctx?.user?.store_id || 'unknown';
const timestamp = Date.now();
const randomToken = Math.random().toString(36).slice(2, 10);
return `storage_transaction_export_${warehouseId}_${timestamp}_${randomToken}`;
}
/**
* 归一化库位流水导出任务ID。
* @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 `${STORAGE_TRANSACTION_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 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,
message: String(safePayload.message || ''),
result: safePayload.result ?? null,
error: String(safePayload.error || ''),
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, progressPayload, STORAGE_TRANSACTION_EXPORT_TASK_CACHE_TTL_SECONDS);
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
this.ctx.logger.warn(`[storage.transaction.export] 写入导出任务缓存失败: ${errorMessage}`);
}
}
/**
* 读取库位流水导出任务进度缓存。
* @param {string} taskId 任务ID
* @return {Promise<Object|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(`[storage.transaction.export] 读取导出任务缓存失败: ${errorMessage}`);
return null;
}
}
}
module.exports = StorageTransactionService;