5551 lines
196 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 { Op } = require('sequelize');
const OrderBaseService = require('./base');
const DEFAULT_PAGE = 1;
const DEFAULT_PAGE_SIZE = 20;
const MAX_PAGE_SIZE = 200;
const BATCH_LIST_MAX_PAGE_SIZE = 500;
const DEFAULT_MAX_WAVE_QUANTITY = 500;
const DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY = 13;
const WAVE_MANUAL_FETCH_FLAG = 'wave_manual_fetch';
const FETCH_TASK_CACHE_KEY_PREFIX = 'wave:fetch:task:';
const FETCH_TASK_CACHE_TTL_SECONDS = 60 * 60 * 2;
const BATCH_CANCEL_TASK_CACHE_KEY_PREFIX = 'wave:batch-cancel:';
const BATCH_CANCEL_TASK_CACHE_TTL_SECONDS = 60 * 60 * 24;
const BATCH_REMOVE_EXCEPTION_ORDERS_TASK_CACHE_KEY_PREFIX = 'wave:batch-remove-exception-orders:';
const BATCH_REMOVE_EXCEPTION_ORDERS_TASK_CACHE_TTL_SECONDS = 60 * 60 * 24;
const BATCH_ALLOCATE_EXPRESS_TASK_CACHE_KEY_PREFIX = 'wave:batch-allocate-express:';
const BATCH_ALLOCATE_EXPRESS_TASK_CACHE_TTL_SECONDS = 60 * 60 * 24;
const BATCH_ALLOCATE_STORAGE_TASK_CACHE_KEY_PREFIX = 'wave:batch-allocate-storage:';
const BATCH_ALLOCATE_STORAGE_TASK_CACHE_TTL_SECONDS = 60 * 60 * 24;
const BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID = 1;
const BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS = [ BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID ];
const BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP = new Map();
class WaveService extends OrderBaseService {
/**
* 初始化波次方法权限配置。
*
* @param {Egg.Context} ctx 请求上下文。
*/
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'groupOrderFetchList,singleOrderFetchList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders';
const _noNeedLog = 'groupOrderFetchList,singleOrderFetchList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders';
const _noNeedAuth = 'groupOrderFetchList,singleOrderFetchList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 构建批次分配快递号链路追踪ID。
*
* 优先使用入参中的 trace_id/traceId,其次尝试读取上下文中的 trace 标识,
* 最后兜底生成带时间戳的随机追踪ID。
*
* @param {Object} [data={}] 入参对象。
* @param {string} [fallback=''] 兜底业务标识(如 taskId)。
* @return {string} 追踪ID。
*/
buildBatchAllocateExpressTraceId(data = {}, fallback = '') {
const normalizedData = this.isPlainObject(data) ? data : {};
const ctxTraceId = this.ctx && this.ctx.traceId !== undefined
? this.ctx.traceId
: this.ctx && this.ctx.requestId !== undefined
? this.ctx.requestId
: this.ctx && this.ctx.state && this.ctx.state.traceId !== undefined
? this.ctx.state.traceId
: '';
const normalizedTraceId = String(
normalizedData.trace_id
|| normalizedData.traceId
|| ctxTraceId
|| fallback
|| ''
).trim();
if (normalizedTraceId) {
return normalizedTraceId;
}
return `wave_allocate_express_trace_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
}
/**
* 构建订单操作日志批量写入数据。
*
* @param {Array<Object>} logItems 日志项。
* @param {number|string} warehouseId 仓库ID。
* @return {Array<Object>} 可直接用于 bulkCreate 的日志行。
*/
buildOrderOperationLogRows(logItems = [], warehouseId = 0) {
if (!Array.isArray(logItems) || logItems.length === 0) {
return [];
}
const normalizedWarehouseId = Number(this.getOrderLogWarehouseId(warehouseId) || 0);
const stateUser = this.isPlainObject(this.ctx && this.ctx.state && this.ctx.state.user)
? this.ctx.state.user
: null;
const ctxUser = this.isPlainObject(this.ctx && this.ctx.user)
? this.ctx.user
: null;
const paramsObject = this.isPlainObject(this.params) ? this.params : {};
const paramsOperator = this.isPlainObject(paramsObject.__operator)
? paramsObject.__operator
: (this.isPlainObject(paramsObject.operator) ? paramsObject.operator : null);
const operatorSource = stateUser || ctxUser || paramsOperator || {};
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
const rawOperatorName = operatorSource.employees_name
?? operatorSource.operator_name
?? operatorSource.real_name
?? operatorSource.name;
const operatorId = rawOperatorId === undefined || rawOperatorId === null
? null
: String(rawOperatorId).trim() || null;
const operatorName = rawOperatorName === undefined || rawOperatorName === null
? 'system'
: String(rawOperatorName).trim() || 'system';
const platformCode = String(operatorSource.platform_code || 'SYSTEM').trim() || 'SYSTEM';
return logItems
.map(item => {
const orderId = Number(item && item.orderId || 0);
const operationCode = String(item && item.operationCode || '').trim() || 'ORDER_WAVE_UPDATE';
const message = String(item && item.message || '').trim();
if (!Number.isInteger(orderId) || orderId <= 0 || !message) {
return null;
}
return {
business_type: 'order',
business_id: `${orderId}`,
operation_code: operationCode,
operator_id: operatorId,
operator_name: operatorName,
external_log_type: 'NONE',
warehouse_id: Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: null,
platform_code: platformCode,
message,
};
})
.filter(Boolean);
}
/**
* 批量写入订单操作日志。
*
* 该方法为业务降级路径,写入失败仅告警,不影响主流程。
*
* @param {Array<Object>} logItems 日志项。
* @param {Object} options 写入选项。
* @param {number|string} options.warehouseId 仓库ID。
* @param {string} [options.scene='wave'] 场景标识,用于日志追踪。
* @return {Promise<number>} 实际写入条数。
*/
async batchCreateOrderOperationLogs(logItems = [], options = {}) {
const rows = this.buildOrderOperationLogRows(logItems, options && options.warehouseId);
const loggerWarn = this.ctx.logger && typeof this.ctx.logger.warn === 'function'
? this.ctx.logger.warn.bind(this.ctx.logger)
: null;
if (rows.length === 0) {
return 0;
}
const operationLogModel = this.ctx.model && this.ctx.model.OperationLog;
if (!operationLogModel || typeof operationLogModel.bulkCreate !== 'function') {
if (loggerWarn) {
loggerWarn('[wave.batchCreateOrderOperationLogs] OperationLog.bulkCreate 不可用,跳过写入', {
scene: String(options && options.scene || 'wave'),
rows: rows.length,
});
}
return 0;
}
try {
await operationLogModel.bulkCreate(rows);
return rows.length;
} catch (error) {
if (loggerWarn) {
loggerWarn('[wave.batchCreateOrderOperationLogs] 批量写订单操作日志失败,不影响主流程', {
scene: String(options && options.scene || 'wave'),
rows: rows.length,
error: error && error.message ? error.message : `${error}`,
});
}
return 0;
}
}
/**
* 构建稳定机器结构标识(可作为抓取接口入参)。
*
* @param {Object} params 结构参数。
* @param {string} params.item_part_type 商品结构来源字段类型。
* @param {string} params.item_part 商品结构来源值。
* @param {boolean} params.distinguish_express 是否区分快递。
* @param {string} params.logistics_name 快递名称。
* @param {string} params.item_snapshot_key 机器明细快照。
* @return {string} 稳定机器结构标识。
*/
buildMachineStructureToken(params = {}) {
const itemPartType = String(params.item_part_type || 'items_hash').trim() || 'items_hash';
const itemPart = encodeURIComponent(String(params.item_part || '').trim());
const distinguishExpress = params.distinguish_express ? '1' : '0';
const logisticsName = encodeURIComponent(String(params.logistics_name || '').trim());
const itemSnapshotKey = encodeURIComponent(String(params.item_snapshot_key || '').trim());
return `v1|${itemPartType}|${itemPart}|${distinguishExpress}|${logisticsName}|${itemSnapshotKey}`;
}
/**
* 解析机器结构标识。
*
* @param {string} token 机器结构标识。
* @return {{ item_part_type: string, item_part: string, distinguish_express: boolean, logistics_name: string, item_snapshot_key: string }} 解析结果。
*/
parseMachineStructureToken(token) {
const normalizedToken = String(token || '').trim();
const parts = normalizedToken.split('|');
if (parts.length < 6 || parts[0] !== 'v1') {
throw new Error('item_detail_machine 格式不合法');
}
const itemPartType = String(parts[1] || '').trim();
if (![ 'items_hash', 'items' ].includes(itemPartType)) {
throw new Error('item_detail_machine item_part_type 不支持');
}
const itemPart = decodeURIComponent(String(parts[2] || '').trim());
if (!itemPart) {
throw new Error('item_detail_machine item_part 不能为空');
}
const distinguishExpress = String(parts[3] || '') === '1';
const logisticsName = decodeURIComponent(String(parts[4] || '').trim());
const itemSnapshotKey = decodeURIComponent(String(parts[5] || '').trim());
return {
item_part_type: itemPartType,
item_part: itemPart,
distinguish_express: distinguishExpress,
logistics_name: logisticsName,
item_snapshot_key: itemSnapshotKey,
};
}
/**
* 获取订单可分组的商品结构值(优先 items_hash)。
*
* @param {Object} order 订单主表记录。
* @return {{ item_part_type: string, item_part: string }} 分组结构值。
*/
getOrderItemPart(order = {}) {
const itemsHash = String(order.items_hash || '').trim();
if (itemsHash) {
return {
item_part_type: 'items_hash',
item_part: itemsHash,
};
}
return {
item_part_type: 'items',
item_part: String(order.items || '').trim(),
};
}
/**
* 读取默认抓取数量(缓存优先,缓存 miss 再读库)。
*
* @param {number|string} warehouseId 仓库ID。
* @return {Promise<number>} 默认抓取数量。
*/
async getDefaultWaveQuantity(warehouseId) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return DEFAULT_MAX_WAVE_QUANTITY;
}
try {
const subjectConfig = await this.getWarehouseSubjectConfig(normalizedWarehouseId);
const maxWaveQuantity = Number(this.getWarehouseSubjectConfigValue(subjectConfig, 'max_wave_quantity'));
if (!Number.isInteger(maxWaveQuantity) || maxWaveQuantity <= 0) {
return DEFAULT_MAX_WAVE_QUANTITY;
}
return maxWaveQuantity;
} catch (error) {
this.ctx.logger.warn('[wave.getDefaultWaveQuantity] 获取仓库默认波次数量失败: %s', error.message);
return DEFAULT_MAX_WAVE_QUANTITY;
}
}
/**
* 读取最小团购抓取数量(缓存优先,缓存 miss 再读库)。
*
* @param {number|string} warehouseId 仓库ID。
* @return {Promise<number>} 最小团购抓取数量。
*/
async getMinGroupOrderFetchQuantity(warehouseId) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY;
}
try {
const subjectConfig = await this.getWarehouseSubjectConfig(normalizedWarehouseId);
const minGroupOrderFetchQuantity = Number(
this.getWarehouseSubjectConfigValue(subjectConfig, 'min_group_order_fetch_quantity')
);
if (!Number.isInteger(minGroupOrderFetchQuantity) || minGroupOrderFetchQuantity <= 0) {
return DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY;
}
return minGroupOrderFetchQuantity;
} catch (error) {
this.ctx.logger.warn('[wave.getMinGroupOrderFetchQuantity] 获取仓库最小团购抓取数量失败: %s', error.message);
return DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY;
}
}
/**
* 读取团购波次编号前缀(缓存优先,缓存 miss 再读库)。
*
* @param {number|string} warehouseId 仓库ID。
* @return {Promise<string>} 团购波次编号前缀。
*/
async getGroupWavePrefix(warehouseId) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return 'B';
}
try {
const subjectConfig = await this.getWarehouseSubjectConfig(normalizedWarehouseId);
const groupWavePrefix = String(
this.getWarehouseSubjectConfigValue(subjectConfig, 'group_wave_prefix') || ''
).trim();
if (!groupWavePrefix) {
return 'B';
}
return groupWavePrefix.slice(0, 5);
} catch (error) {
this.ctx.logger.warn('[wave.getGroupWavePrefix] 获取仓库团购波次前缀失败: %s', error.message);
return 'B';
}
}
/**
* 统一读取仓库主体配置(缓存优先,缓存 miss 回源数据库)。
*
* @param {number|string} warehouseId 仓库ID。
* @return {Promise<Object>} 仓库主体配置对象。
*/
async getWarehouseSubjectConfig(warehouseId) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return {};
}
const deliveryOrderService = this.ctx.service.systems && this.ctx.service.systems.deliveryOrder;
if (!deliveryOrderService || typeof deliveryOrderService.getStoreSubjectConfig !== 'function') {
return {};
}
const subjectConfig = await deliveryOrderService.getStoreSubjectConfig(normalizedWarehouseId);
return this.isPlainObject(subjectConfig) ? subjectConfig : {};
}
/**
* 从仓库主体配置中读取字段值,优先 subject_config 内嵌配置。
*
* @param {Object} subjectConfig 仓库主体配置。
* @param {string} key 字段名。
* @return {*} 字段值。
*/
getWarehouseSubjectConfigValue(subjectConfig = {}, key = '') {
const normalizedKey = String(key || '').trim();
if (!normalizedKey) {
return undefined;
}
const normalizedSubjectConfig = this.isPlainObject(subjectConfig) ? subjectConfig : {};
const nestedSubjectConfig = this.isPlainObject(normalizedSubjectConfig.subject_config)
? normalizedSubjectConfig.subject_config
: {};
if (nestedSubjectConfig[normalizedKey] !== undefined) {
return nestedSubjectConfig[normalizedKey];
}
return normalizedSubjectConfig[normalizedKey];
}
/**
* 解析抓取结构请求参数。
*
* @param {Object} data 请求参数。
* @param {number} defaultQuantity 默认抓取数量。
* @return {Array<Object>} 结构化请求。
*/
normalizeFetchStructureRequests(data = {}, defaultQuantity = DEFAULT_MAX_WAVE_QUANTITY) {
const requestData = this.isPlainObject(data) ? data : {};
const rawStructureList = requestData.structure_list;
if (!Array.isArray(rawStructureList) || rawStructureList.length === 0) {
throw new Error('structure_list 必须是非空数组');
}
return rawStructureList.map((item, index) => {
if (!this.isPlainObject(item)) {
throw new Error(`structure_list[${index}] 必须是对象`);
}
const itemDetailMachine = String(item.item_detail_machine || '').trim();
if (!itemDetailMachine) {
throw new Error(`structure_list[${index}].item_detail_machine 不能为空`);
}
const parsedToken = this.parseMachineStructureToken(itemDetailMachine);
const quantity = item.quantity === undefined || item.quantity === null || item.quantity === ''
? defaultQuantity
: this.normalizePositiveInteger(item.quantity, `structure_list[${index}].quantity`, defaultQuantity);
if (!Number.isInteger(quantity) || quantity <= 0) {
throw new Error(`structure_list[${index}].quantity 必须大于 0`);
}
return {
index,
item_detail_machine: itemDetailMachine,
quantity,
...parsedToken,
};
});
}
/**
* 生成可排序且足够唯一的 wave_id。
*
* @param {number} suffix 同批次偏移量。
* @return {number} 波次ID。
*/
generateWaveId(suffix = 0) {
const base = Date.now() * 1000;
const randomPart = Math.floor(Math.random() * 900) + 100;
return base + randomPart + Number(suffix || 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}`;
}
/**
* 查询当天前缀下的下一个波次序号。
*
* @param {string} prefix 波次编号前缀。
* @param {string} datePart 日期片段(YYYYMMDD)。
* @param {Object} transaction Sequelize 事务。
* @return {Promise<number>} 下一个序号(最小为 1)。
*/
async getNextWaveNoSequence(prefix, datePart, transaction) {
const normalizedPrefix = String(prefix || '').trim() || 'B';
const normalizedDatePart = String(datePart || '').trim();
const pattern = `${normalizedPrefix}${normalizedDatePart}%`;
const sql = `
SELECT wave_no
FROM wms_wave_batch
WHERE wave_no LIKE :pattern
ORDER BY wave_no DESC
LIMIT 1
`;
const rows = await this.ctx.model.query(sql, {
replacements: { pattern },
type: this.ctx.model.QueryTypes.SELECT,
transaction,
});
const latestWaveNo = String(rows && rows[0] && rows[0].wave_no || '').trim();
if (!latestWaveNo) {
return 1;
}
const match = latestWaveNo.match(/(\d{5})$/);
const lastSequence = match ? Number(match[1]) : 0;
if (!Number.isInteger(lastSequence) || lastSequence <= 0) {
return 1;
}
return lastSequence + 1;
}
/**
* 构建波次编号。
*
* @param {string} [prefix='B'] 波次编号前缀。
* @param {string} [datePart=''] 日期片段(YYYYMMDD)。
* @param {number|string} [sequence=1] 当天序号。
* @return {string} 波次编号。
*/
buildWaveNo(prefix = 'B', datePart = '', sequence = 1) {
const normalizedPrefix = String(prefix || '').trim();
const normalizedDatePart = String(datePart || '').trim();
const normalizedSequence = Number(sequence || 0);
const safeSequence = Number.isInteger(normalizedSequence) && normalizedSequence > 0 ? normalizedSequence : 1;
return `${normalizedPrefix}${normalizedDatePart}${String(safeSequence).padStart(5, '0')}`;
}
/**
* 获取波次创建人。
*
* 优先级:employees_name > real_name > name > id(字符串) > system。
*
* @return {string} 创建人。
*/
getWaveCreator() {
const user = this.isPlainObject(this.ctx.user) ? this.ctx.user : {};
const creator = String(user.employees_name || user.real_name || user.name || '').trim();
if (creator) {
return creator;
}
const userId = user.id;
if (userId !== undefined && userId !== null && userId !== '') {
return `${userId}`;
}
return 'system';
}
/**
* 从 SQL 执行结果中提取 insertId。
*
* @param {*} queryResult Sequelize query 返回值。
* @return {number} 自增主键ID,提取失败返回 0。
*/
extractInsertId(queryResult) {
if (Array.isArray(queryResult)) {
const [ first, second ] = queryResult;
const firstInsertId = Number(first && first.insertId || 0);
if (Number.isInteger(firstInsertId) && firstInsertId > 0) {
return firstInsertId;
}
const secondInsertId = Number(second && second.insertId || 0);
if (Number.isInteger(secondInsertId) && secondInsertId > 0) {
return secondInsertId;
}
}
const directInsertId = Number(queryResult && queryResult.insertId || 0);
if (Number.isInteger(directInsertId) && directInsertId > 0) {
return directInsertId;
}
return 0;
}
/**
* 从 LAST_INSERT_ID 查询结果中提取 insertId。
*
* @param {*} queryResult Sequelize query 返回值。
* @return {number} 自增主键ID,提取失败返回 0。
*/
extractLastInsertId(queryResult) {
const directInsertId = this.extractInsertId(queryResult);
if (Number.isInteger(directInsertId) && directInsertId > 0) {
return directInsertId;
}
if (!Array.isArray(queryResult)) {
return 0;
}
const [ first ] = queryResult;
if (Array.isArray(first) && first.length > 0) {
for (const row of first) {
const rowInsertId = Number(
row && (row.insertId || row.insert_id || row.LAST_INSERT_ID || row.last_insert_id) || 0
);
if (Number.isInteger(rowInsertId) && rowInsertId > 0) {
return rowInsertId;
}
}
}
return 0;
}
/**
* 新增一条“已就绪”波次批次记录,并返回自增 wave_id。
*
* @param {Object} params 入参。
* @param {number|string} params.warehouseId 仓库ID。
* @param {number|string} params.totalOrders 订单总数。
* @param {string} params.itemDetailMachine 机器结构标识。
* @param {string} params.itemPartType 商品结构来源字段类型。
* @param {string} params.itemPart 商品结构来源值。
* @param {number|boolean|string} params.distinguishExpress 是否区分快递(归一化为0/1)。
* @param {string} params.logisticsName 快递名称。
* @param {string} params.itemSnapshotKey 机器明细快照。
* @param {string} [params.wavePrefix] 波次编号前缀。
* @param {string} [params.waveNo] 波次编号(传入则直接使用)。
* @param {Object} params.transaction Sequelize 事务。
* @return {Promise<{waveId: number, waveNo: string}>} 创建结果。
*/
async createWaveBatchReady({
warehouseId,
totalOrders,
itemDetailMachine,
itemPartType,
itemPart,
distinguishExpress,
logisticsName,
itemSnapshotKey,
wavePrefix,
waveNo,
transaction,
} = {}) {
const normalizedWarehouseId = Number(warehouseId || 0);
const normalizedTotalOrders = Number(totalOrders || 0);
const normalizedItemDetailMachine = String(itemDetailMachine || '').trim();
const normalizedItemPartType = String(itemPartType || '').trim();
const normalizedItemPart = String(itemPart || '').trim();
const normalizedDistinguishExpress = distinguishExpress === true || Number(distinguishExpress) === 1 ? 1 : 0;
const normalizedLogisticsName = String(logisticsName || '').trim();
const normalizedItemSnapshotKey = String(itemSnapshotKey || '').trim();
const normalizedWavePrefix = String(wavePrefix || '').trim() || 'B';
const normalizedWaveNoInput = String(waveNo || '').trim();
let normalizedWaveNo = normalizedWaveNoInput;
if (!normalizedWaveNo) {
const datePart = this.getCurrentDatePart();
const sequence = await this.getNextWaveNoSequence(normalizedWavePrefix, datePart, transaction);
normalizedWaveNo = this.buildWaveNo(normalizedWavePrefix, datePart, sequence);
}
const creator = this.getWaveCreator();
const sql = `
INSERT INTO wms_wave_batch
(
wave_no,
wave_type,
wave_status,
total_orders,
processed_orders,
item_detail_machine,
item_part_type,
item_part,
distinguish_express,
logistics_name,
item_snapshot_key,
warehouse_id,
creator,
create_time,
update_time
)
VALUES
(
:waveNo,
1,
1,
:totalOrders,
0,
:itemDetailMachine,
:itemPartType,
:itemPart,
:distinguishExpress,
:logisticsName,
:itemSnapshotKey,
:warehouseId,
:creator,
NOW(),
NOW()
)
`;
const createResult = await this.ctx.model.query(sql, {
replacements: {
waveNo: normalizedWaveNo,
totalOrders: normalizedTotalOrders,
itemDetailMachine: normalizedItemDetailMachine,
itemPartType: normalizedItemPartType,
itemPart: normalizedItemPart,
distinguishExpress: normalizedDistinguishExpress,
logisticsName: normalizedLogisticsName,
itemSnapshotKey: normalizedItemSnapshotKey,
warehouseId: Number.isInteger(normalizedWarehouseId) ? normalizedWarehouseId : 0,
creator,
},
transaction,
});
let insertedWaveId = this.extractInsertId(createResult);
if (!Number.isInteger(insertedWaveId) || insertedWaveId <= 0) {
const fallbackResult = await this.ctx.model.query('SELECT LAST_INSERT_ID() AS insertId', {
transaction,
});
insertedWaveId = this.extractLastInsertId(fallbackResult);
}
if (!Number.isInteger(insertedWaveId) || insertedWaveId <= 0) {
throw new Error('创建波次失败,未获取到自增 wave_id');
}
return {
waveId: insertedWaveId,
waveNo: normalizedWaveNo,
};
}
/**
* 构建抓取候选订单筛选条件。
*
* @param {Object} structure 结构化请求。
* @return {Object} Sequelize where 条件。
*/
buildFetchWhere(structure = {}) {
const where = {
step: { [Op.in]: [ 1, 2, 3 ] },
status: { [Op.ne]: 'cancel' },
outbound_status: { [Op.ne]: 'padding' },
wave_id: 0,
};
const itemPartType = String(structure.item_part_type || '').trim();
const itemPart = String(structure.item_part || '').trim();
if (itemPartType === 'items_hash') {
where.items_hash = itemPart;
} else {
where.items = itemPart;
}
if (structure.distinguish_express) {
where.logistics_name = String(structure.logistics_name || '').trim();
}
return where;
}
/**
* 按单个结构抓取订单并写入同一波次。
*
* @param {Object} model 订单主表模型。
* @param {Object} structure 结构化请求。
* @param {number|string} warehouseId 仓库ID。
* @param {string} [wavePrefix='B'] 波次编号前缀。
* @param {number} [minGroupOrderFetchQuantity=13] 最小团购抓取数量。
* @param {Object} [options={}] 额外抓取选项。
* @param {number} [options.maxFetchQuantity=0] 本结构最大抓取订单数上限,0 表示不限制。
* @return {Promise<Object>} 单结构抓取结果。
*/
async fetchSingleStructure(
model,
structure = {},
warehouseId = 0,
wavePrefix = 'B',
minGroupOrderFetchQuantity = DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY,
options = {}
) {
const { ctx } = this;
const where = this.buildFetchWhere(structure);
const requestedQuantity = Number(structure.quantity || 0);
const normalizedOptions = this.isPlainObject(options) ? options : {};
const normalizedMaxFetchQuantity = Number.isInteger(Number(normalizedOptions.maxFetchQuantity))
&& Number(normalizedOptions.maxFetchQuantity) > 0
? Number(normalizedOptions.maxFetchQuantity)
: 0;
const normalizedMinGroupOrderFetchQuantity = Number.isInteger(Number(minGroupOrderFetchQuantity))
&& Number(minGroupOrderFetchQuantity) > 0
? Number(minGroupOrderFetchQuantity)
: DEFAULT_MIN_GROUP_ORDER_FETCH_QUANTITY;
const allWaveIds = [];
const allOrderIds = [];
const fetchedOrderLogItems = [];
let totalFetchedQuantity = 0;
let remainingFetchQuantity = normalizedMaxFetchQuantity;
let stopReason = '';
const transaction = await ctx.model.transaction();
try {
for (;;) {
let fetchLimit = requestedQuantity;
if (normalizedMaxFetchQuantity > 0) {
if (remainingFetchQuantity <= 0) {
stopReason = '达到最大抓取上限';
break;
}
fetchLimit = Math.min(fetchLimit, remainingFetchQuantity);
}
const rows = await model.findAll({
where,
attributes: [ 'id' ],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
order: [[ 'id', 'DESC' ]],
limit: fetchLimit,
});
const candidateOrderIds = rows
.map(row => Number(row && row.id || 0))
.filter(id => Number.isInteger(id) && id > 0);
if (candidateOrderIds.length === 0) {
if (totalFetchedQuantity === 0) {
stopReason = '无可抓取订单';
}
break;
}
if (candidateOrderIds.length < normalizedMinGroupOrderFetchQuantity) {
stopReason = '剩余订单低于最小团购抓取数量';
break;
}
const { waveId, waveNo } = await this.createWaveBatchReady({
warehouseId,
totalOrders: candidateOrderIds.length,
itemDetailMachine: structure.item_detail_machine,
itemPartType: structure.item_part_type,
itemPart: structure.item_part,
distinguishExpress: structure.distinguish_express,
logisticsName: structure.logistics_name,
itemSnapshotKey: structure.item_snapshot_key,
wavePrefix,
transaction,
});
const orderFlagExpression = this.app.Sequelize.literal(`CASE
WHEN order_flag IS NULL OR order_flag = '' THEN '${WAVE_MANUAL_FETCH_FLAG}'
WHEN order_flag LIKE '%${WAVE_MANUAL_FETCH_FLAG}%' THEN order_flag
ELSE CONCAT(order_flag, ',${WAVE_MANUAL_FETCH_FLAG}')
END`);
await model.update({
wave_id: waveId,
wave_no: waveNo,
order_flag: orderFlagExpression,
}, {
where: {
id: { [Op.in]: candidateOrderIds },
wave_id: 0,
},
transaction,
});
const grabbedRows = await model.findAll({
where: {
id: { [Op.in]: candidateOrderIds },
wave_id: waveId,
},
attributes: [ 'id' ],
raw: true,
transaction,
});
const grabbedOrderIds = grabbedRows
.map(row => Number(row && row.id || 0))
.filter(id => Number.isInteger(id) && id > 0)
.sort((a, b) => a - b);
const fetchedQuantity = grabbedOrderIds.length;
if (fetchedQuantity <= 0) {
await this.ctx.model.query(`
DELETE FROM wms_wave_batch
WHERE wave_id = :waveId
`, {
replacements: { waveId },
transaction,
});
if (totalFetchedQuantity === 0) {
stopReason = '无可抓取订单';
}
break;
}
if (fetchedQuantity !== candidateOrderIds.length) {
await this.ctx.model.query(`
UPDATE wms_wave_batch
SET total_orders = :totalOrders,
update_time = NOW()
WHERE wave_id = :waveId
`, {
replacements: {
waveId,
totalOrders: fetchedQuantity,
},
transaction,
});
}
allWaveIds.push(waveId);
allOrderIds.push(...grabbedOrderIds);
fetchedOrderLogItems.push(...grabbedOrderIds.map(orderId => ({
orderId,
operationCode: 'ORDER_WAVE_ASSIGN',
message: `订单被分配到波次 ${waveNo}`,
})));
totalFetchedQuantity += fetchedQuantity;
if (normalizedMaxFetchQuantity > 0) {
remainingFetchQuantity -= fetchedQuantity;
if (remainingFetchQuantity <= 0) {
stopReason = '达到最大抓取上限';
break;
}
}
}
await transaction.commit();
await this.batchCreateOrderOperationLogs(fetchedOrderLogItems, {
warehouseId,
scene: 'fetchSingleStructure',
});
const mergedOrderIds = [ ...new Set(allOrderIds) ].sort((a, b) => a - b);
let reason = stopReason;
if (!reason && totalFetchedQuantity > 0 && totalFetchedQuantity < requestedQuantity) {
reason = '可抓取订单不足';
}
return {
item_detail_machine: structure.item_detail_machine,
request_quantity: requestedQuantity,
fetched_quantity: totalFetchedQuantity,
...(normalizedMaxFetchQuantity > 0 ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
...(normalizedMaxFetchQuantity > 0 ? { limit_reached: totalFetchedQuantity >= normalizedMaxFetchQuantity } : {}),
wave_id: allWaveIds.length > 0 ? allWaveIds[0] : 0,
wave_ids: allWaveIds,
order_ids: mergedOrderIds,
auto_fetch_disabled: true,
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
...(reason ? { reason } : {}),
};
} catch (error) {
await transaction.rollback();
throw error;
}
}
normalizeBoolean(value, defaultValue = false) {
if (value === undefined || value === null || value === '') {
return defaultValue;
}
if (typeof value === 'boolean') {
return value;
}
if (typeof value === 'number') {
return value === 1;
}
const normalized = String(value).trim().toLowerCase();
if ([ '1', 'true', 'yes', 'y', 'on' ].includes(normalized)) {
return true;
}
if ([ '0', 'false', 'no', 'n', 'off' ].includes(normalized)) {
return false;
}
return defaultValue;
}
normalizePositiveInteger(value, fieldName, defaultValue = 0) {
if (value === undefined || value === null || value === '') {
return defaultValue;
}
const num = Number(value);
if (!Number.isInteger(num) || num < 0) {
throw new Error(`${fieldName} 参数不合法`);
}
return num;
}
/**
* 解析必填的正整数参数。
*
* @param {*} value 原始参数值。
* @param {string} fieldName 字段名称。
* @return {number} 归一化后的正整数。
*/
normalizeRequiredPositiveInteger(value, fieldName) {
if (value === undefined || value === null || value === '') {
throw new Error(`${fieldName} 参数不能为空`);
}
const normalizedValue = Number(value);
if (!Number.isInteger(normalizedValue) || normalizedValue <= 0) {
throw new Error(`${fieldName} 参数必须为正整数`);
}
return normalizedValue;
}
/**
* 归一化 ids 入参为去重后的正整数数组。
*
* 支持数组、逗号分隔字符串、单个 number/string。
*
* @param {Array<number|string>|number|string} value 原始 ids 入参。
* @return {Array<number>} 归一化后的 ids 数组。
*/
normalizeIdsInput(value) {
let sourceList = [];
if (Array.isArray(value)) {
sourceList = value;
} else if (typeof value === 'string') {
sourceList = value.split(',');
} else if (typeof value === 'number') {
sourceList = [ value ];
} else {
sourceList = [];
}
const normalizedIds = sourceList
.map(item => String(item === undefined || item === null ? '' : item).trim())
.filter(item => item !== '')
.map(item => Number(item))
.filter(item => Number.isInteger(item) && item > 0);
return [ ...new Set(normalizedIds) ];
}
/**
* 规范化分页参数。
*
* @param {Object} data 请求参数。
* @param {Object} data.pagination 分页参数对象。
* @param {number|string} data.pagination.page 页码。
* @param {number|string} data.pagination.pageSize 每页数量(驼峰写法,可用)。
* @param {number|string} data.pagination.page_size 每页数量(下划线写法,可用)。
* @param {number|string} data.pagination.limit 每页数量(limit 写法,可用)。
* @param {number|string} data.pagination.size 每页数量(size 写法,可用)。
* @param {Object} options 规范化选项。
* @param {number|string} options.maxPageSize 每页数量上限。
* @return {{ page: number, pageSize: number }} 规范化后的分页信息。
*/
normalizePagination(data = {}, options = {}) {
const pagination = this.isPlainObject(data && data.pagination) ? data.pagination : {};
const pageSource = pagination.page;
const pageSizeSource = pagination.pageSize ?? pagination.page_size ?? pagination.limit ?? pagination.size;
const maxPageSizeSource = Number(options.maxPageSize || MAX_PAGE_SIZE);
const maxPageSize = Number.isInteger(maxPageSizeSource) && maxPageSizeSource > 0
? maxPageSizeSource
: MAX_PAGE_SIZE;
const page = Number(pageSource || DEFAULT_PAGE);
const pageSize = Number(pageSizeSource || DEFAULT_PAGE_SIZE);
const normalizedPage = Number.isInteger(page) && page > 0 ? page : DEFAULT_PAGE;
const normalizedPageSize = Number.isInteger(pageSize) && pageSize > 0
? Math.min(pageSize, maxPageSize)
: DEFAULT_PAGE_SIZE;
return {
page: normalizedPage,
pageSize: normalizedPageSize,
};
}
/**
* 规范化波次状态列表。
*
* @param {Array<number|string>} value 波次状态列表。
* @return {Array<number>} 规范化后的状态数组。
*/
normalizeWaveStatusList(value) {
if (!Array.isArray(value)) {
return [ 0, 1 ];
}
const statusList = value
.map(item => Number(item))
.filter(item => Number.isInteger(item));
if (statusList.length === 0) {
return [ 0, 1 ];
}
return [ ...new Set(statusList) ];
}
/**
* 规范化波次列表库位分配状态筛选值。
*
* @param {string} value 入参筛选值。
* @return {string} 规范化后的筛选值,未传时返回空字符串。
*/
normalizeBatchListStorageAssignmentStatusFilter(value) {
if (value === undefined || value === null || value === '') {
return '';
}
const normalizedValue = String(value).trim();
if (!normalizedValue) {
return '';
}
const allowedValues = [ '未分配', '部分分配', '已分配' ];
if (!allowedValues.includes(normalizedValue)) {
throw new Error(`storage_assignment_status 参数不合法,仅支持: ${allowedValues.join('、')}`);
}
return normalizedValue;
}
/**
* 解析模型对应的 SQL 表名并完成安全转义。
*
* @param {Object} model Sequelize 模型对象。
* @return {string} 可直接拼接到 SQL 的表名。
*/
getModelTableSqlName(model) {
const rawTableName = model && typeof model.getTableName === 'function'
? model.getTableName()
: model && model.tableName;
const tableName = typeof rawTableName === 'string'
? rawTableName
: rawTableName && typeof rawTableName.tableName === 'string'
? rawTableName.tableName
: '';
const normalizedTableName = String(tableName || '').trim();
if (!normalizedTableName) {
throw new Error('订单模型表名解析失败');
}
const tableParts = normalizedTableName.split('.').map(part => String(part || '').trim()).filter(Boolean);
if (tableParts.length === 0) {
throw new Error('订单模型表名解析失败');
}
for (const tablePart of tableParts) {
if (!/^[a-zA-Z0-9_$]+$/.test(tablePart)) {
throw new Error(`订单模型表名不合法: ${normalizedTableName}`);
}
}
return tableParts.map(part => `\`${part}\``).join('.');
}
/**
* 构建波次列表库位分配状态筛选 SQL 条件。
*
* @param {string} statusFilter 库位分配状态筛选值。
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
*/
buildBatchListStorageAssignmentFilterClause(statusFilter = '') {
const normalizedStatusFilter = this.normalizeBatchListStorageAssignmentStatusFilter(statusFilter);
if (!normalizedStatusFilter) {
return {
sql: '',
replacements: {},
};
}
const totalExpr = 'COALESCE(wave_order_stats.order_total, 0)';
const storageNoneExpr = 'COALESCE(wave_order_stats.storage_none_count, 0)';
const storageFinExpr = 'COALESCE(wave_order_stats.storage_fin_count, 0)';
const storageErrorExpr = 'COALESCE(wave_order_stats.storage_error_count, 0)';
let whereClause = '';
if (normalizedStatusFilter === '已分配') {
whereClause = `
${storageFinExpr} = ${totalExpr}
AND ${totalExpr} > 0
`;
} else if (normalizedStatusFilter === '部分分配') {
whereClause = `
${storageErrorExpr} = 0
AND ${storageNoneExpr} <> ${totalExpr}
AND ${storageFinExpr} <> ${totalExpr}
`;
} else if (normalizedStatusFilter === '未分配') {
return {
sql: `
AND (
${totalExpr} = 0
OR ${storageErrorExpr} > 0
OR ${storageNoneExpr} = ${totalExpr}
)`,
replacements: {},
};
}
return {
sql: `
AND ${whereClause}`,
replacements: {},
};
}
/**
* 构建波次列表 where 条件(白名单字段)。
*
* @param {Object} whereData 查询 where 入参。
* @return {{ sql: string, replacements: Object, storageAssignmentStatus: string }} SQL 条件片段、参数与库位分配状态筛选值。
*/
buildBatchListWhereClause(whereData = {}) {
const normalizedWhere = this.isPlainObject(whereData) ? whereData : {};
const whereKeys = Object.keys(normalizedWhere);
if (whereKeys.includes('warehouse_id') || whereKeys.includes('warehouseId')) {
throw new Error('where 中禁止传入 warehouse_id 或 warehouseId');
}
const allowedFields = [
'wave_id',
'wave_no',
'wave_type',
'wave_status',
'creator',
'logistics_name',
'item_part_type',
'item_part',
'item_snapshot_key',
'item_detail_machine',
'distinguish_express',
'total_orders_min',
'total_orders_max',
'processed_orders_min',
'processed_orders_max',
'storage_assignment_status',
];
const invalidFields = whereKeys.filter(key => !allowedFields.includes(key));
if (invalidFields.length > 0) {
throw new Error(`where 存在不支持的字段: ${invalidFields.join(',')}`);
}
const conditions = [];
const replacements = {};
const appendIntegerEqualCondition = (fieldKey, columnName, replacementKey, allowZero = true) => {
const value = normalizedWhere[fieldKey];
if (value === undefined || value === null || value === '') {
return;
}
const numberValue = Number(value);
const isValid = Number.isInteger(numberValue) && (allowZero ? numberValue >= 0 : numberValue > 0);
if (!isValid) {
throw new Error(`${fieldKey} 参数不合法`);
}
conditions.push(`${columnName} = :${replacementKey}`);
replacements[replacementKey] = numberValue;
};
const appendLikeCondition = (fieldKey, columnName, replacementKey) => {
const value = normalizedWhere[fieldKey];
if (value === undefined || value === null || value === '') {
return;
}
const normalizedValue = String(value).trim();
if (!normalizedValue) {
return;
}
conditions.push(`${columnName} LIKE :${replacementKey}`);
replacements[replacementKey] = `%${normalizedValue}%`;
};
const appendMinCondition = (fieldKey, columnName, replacementKey) => {
const value = normalizedWhere[fieldKey];
if (value === undefined || value === null || value === '') {
return;
}
const numberValue = Number(value);
if (!Number.isFinite(numberValue)) {
throw new Error(`${fieldKey} 参数不合法`);
}
conditions.push(`${columnName} >= :${replacementKey}`);
replacements[replacementKey] = numberValue;
};
const appendMaxCondition = (fieldKey, columnName, replacementKey) => {
const value = normalizedWhere[fieldKey];
if (value === undefined || value === null || value === '') {
return;
}
const numberValue = Number(value);
if (!Number.isFinite(numberValue)) {
throw new Error(`${fieldKey} 参数不合法`);
}
conditions.push(`${columnName} <= :${replacementKey}`);
replacements[replacementKey] = numberValue;
};
appendIntegerEqualCondition('wave_id', 'wave_id', 'whereWaveId', false);
appendLikeCondition('wave_no', 'wave_no', 'whereWaveNo');
appendIntegerEqualCondition('wave_type', 'wave_type', 'whereWaveType');
appendIntegerEqualCondition('wave_status', 'wave_status', 'whereWaveStatus');
appendLikeCondition('creator', 'creator', 'whereCreator');
appendLikeCondition('logistics_name', 'logistics_name', 'whereLogisticsName');
appendLikeCondition('item_part', 'item_part', 'whereItemPart');
appendLikeCondition('item_snapshot_key', 'item_snapshot_key', 'whereItemSnapshotKey');
appendLikeCondition('item_detail_machine', 'item_detail_machine', 'whereItemDetailMachine');
const itemPartType = normalizedWhere.item_part_type;
if (itemPartType !== undefined && itemPartType !== null && itemPartType !== '') {
const normalizedItemPartType = String(itemPartType).trim();
if (!normalizedItemPartType) {
throw new Error('item_part_type 参数不合法');
}
conditions.push('item_part_type = :whereItemPartType');
replacements.whereItemPartType = normalizedItemPartType;
}
const distinguishExpress = normalizedWhere.distinguish_express;
if (distinguishExpress !== undefined && distinguishExpress !== null && distinguishExpress !== '') {
let normalizedDistinguishExpress;
if (typeof distinguishExpress === 'boolean') {
normalizedDistinguishExpress = distinguishExpress ? 1 : 0;
} else if (typeof distinguishExpress === 'number') {
if (distinguishExpress !== 0 && distinguishExpress !== 1) {
throw new Error('distinguish_express 参数不合法');
}
normalizedDistinguishExpress = distinguishExpress;
} else {
const boolText = String(distinguishExpress).trim().toLowerCase();
if ([ '1', 'true', 'yes', 'y', 'on' ].includes(boolText)) {
normalizedDistinguishExpress = 1;
} else if ([ '0', 'false', 'no', 'n', 'off' ].includes(boolText)) {
normalizedDistinguishExpress = 0;
} else {
throw new Error('distinguish_express 参数不合法');
}
}
conditions.push('distinguish_express = :whereDistinguishExpress');
replacements.whereDistinguishExpress = normalizedDistinguishExpress;
}
appendMinCondition('total_orders_min', 'total_orders', 'whereTotalOrdersMin');
appendMaxCondition('total_orders_max', 'total_orders', 'whereTotalOrdersMax');
appendMinCondition('processed_orders_min', 'processed_orders', 'whereProcessedOrdersMin');
appendMaxCondition('processed_orders_max', 'processed_orders', 'whereProcessedOrdersMax');
const storageAssignmentStatus = this.normalizeBatchListStorageAssignmentStatusFilter(
normalizedWhere.storage_assignment_status
);
return {
sql: conditions.length > 0 ? `\n AND ${conditions.join('\n AND ')}` : '',
replacements,
storageAssignmentStatus,
};
}
/**
* 解析分配状态。
*
* @param {number} total 总数量。
* @param {number} noneCount 未分配数量。
* @param {number} finCount 已分配数量。
* @param {number} errorCount 分配异常数量。
* @param {{ none?: string, partial?: string, finished?: string, error?: string }} [labels] 状态文案映射。
* @return {string} 分配状态。
*/
resolveAssignmentStatus(total, noneCount, finCount, errorCount = 0, labels = {}) {
const normalizedTotal = Number(total || 0);
const normalizedNoneCount = Number(noneCount || 0);
const normalizedFinCount = Number(finCount || 0);
const normalizedErrorCount = Number(errorCount || 0);
const normalizedLabels = labels && typeof labels === 'object' ? labels : {};
const noneLabel = String(normalizedLabels.none || '未分配');
const partialLabel = String(normalizedLabels.partial || '部分分配');
const finishedLabel = String(normalizedLabels.finished || '已分配');
const errorLabel = String(normalizedLabels.error || '分配异常');
if (normalizedErrorCount > 0) {
return errorLabel;
}
if (normalizedTotal <= 0 || normalizedNoneCount === normalizedTotal) {
return noneLabel;
}
if (normalizedFinCount === normalizedTotal) {
return finishedLabel;
}
return partialLabel;
}
normalizeSkuText(value) {
if (value === undefined || value === null) {
return '';
}
return String(value).trim();
}
normalizeShopName(value) {
if (value === undefined || value === null) {
return '';
}
return String(value).trim();
}
parseItemSnapshot(rawSnapshot) {
if (!rawSnapshot) {
return {};
}
if (typeof rawSnapshot === 'string') {
try {
const parsed = JSON.parse(rawSnapshot);
return parsed && typeof parsed === 'object' ? parsed : {};
} catch {
return {};
}
}
return typeof rawSnapshot === 'object' ? rawSnapshot : {};
}
normalizeOrderItemRow(row = {}) {
const snapshot = this.parseItemSnapshot(row.item_snapshot);
const stockIdRaw = snapshot.stock_id ?? row.stock_id;
const quantityRaw = row.plan_qty;
const stockId = Number(stockIdRaw || 0);
const quantity = Number(quantityRaw || 0);
return {
stock_id: Number.isInteger(stockId) && stockId > 0 ? stockId : 0,
item_code: String(snapshot.item_code ?? row.item_code ?? '').trim(),
item_name: String(snapshot.item_name ?? row.item_name ?? '').trim(),
barcode: String(snapshot.barcode ?? '').trim(),
quantity: Number.isFinite(quantity) && quantity > 0 ? quantity : 0,
};
}
mergeOrderItemDetails(itemRows = []) {
const merged = new Map();
for (const row of itemRows) {
const normalized = this.normalizeOrderItemRow(row);
if (!normalized.item_code || normalized.quantity <= 0) {
continue;
}
const key = [
normalized.stock_id,
normalized.item_code,
normalized.item_name,
normalized.barcode,
].join('||');
if (!merged.has(key)) {
merged.set(key, {
stock_id: normalized.stock_id,
item_code: normalized.item_code,
item_name: normalized.item_name,
barcode: normalized.barcode,
quantity: 0,
});
}
merged.get(key).quantity += normalized.quantity;
}
return Array.from(merged.values())
.sort((a, b) => {
if (a.stock_id !== b.stock_id) return a.stock_id - b.stock_id;
return String(a.item_code).localeCompare(String(b.item_code));
});
}
buildItemSummary(itemDetails = []) {
if (!Array.isArray(itemDetails) || itemDetails.length === 0) {
return '';
}
return itemDetails
.map(item => {
const name = String(item.item_name || '').trim();
const barcode = String(item.barcode || item.item_code || '').trim();
const qty = item.quantity;
return `${name}${barcode ? `(${barcode})` : ''}×${qty}`;
})
.join(' | ');
}
buildItemSnapshotKey(itemDetails = []) {
if (!Array.isArray(itemDetails) || itemDetails.length === 0) {
return '';
}
return itemDetails.map(item => [
item.stock_id,
item.item_code,
item.item_name,
item.barcode,
item.quantity,
].join('::')).join('|');
}
orderMatchesIncludeSku(itemDetails = [], includeSku = '') {
const token = String(includeSku || '').trim().toLowerCase();
if (!token) {
return true;
}
return itemDetails.some(item => String(item.item_code || '').toLowerCase().includes(token));
}
buildCoarseGroupKey(order = {}, distinguishExpress = false) {
const itemsHash = String(order.items_hash || '').trim();
const itemsText = String(order.items || '').trim();
const logisticsName = String(order.logistics_name || '').trim();
const itemPart = itemsHash || itemsText;
if (!itemPart) {
return '';
}
return distinguishExpress ? `${itemPart}||${logisticsName}` : itemPart;
}
buildStatusSummary(orders = []) {
const summary = {
post_none: 0,
post_fin: 0,
post_padding: 0,
pick_none: 0,
pick_fin: 0,
outbound_none: 0,
outbound_fin: 0,
};
for (const order of orders) {
const postStatus = String(order.post_status || '');
const pickStatus = String(order.pick_status || '');
const outboundStatus = String(order.outbound_status || '');
if (postStatus === 'none') summary.post_none += 1;
if (postStatus === 'fin') summary.post_fin += 1;
if (postStatus === 'padding') summary.post_padding += 1;
if (pickStatus === 'none') summary.pick_none += 1;
if (pickStatus === 'fin') summary.pick_fin += 1;
if (outboundStatus === 'none') summary.outbound_none += 1;
if (outboundStatus === 'fin') summary.outbound_fin += 1;
}
return summary;
}
buildGroupKey(order, itemDetails = [], options = {}) {
const itemSummary = this.buildItemSummary(itemDetails);
const itemSnapshotKey = this.buildItemSnapshotKey(itemDetails);
const logisticsName = String(order.logistics_name || '').trim();
const baseParts = [ itemSnapshotKey ];
if (options.distinguishExpress) {
baseParts.push(logisticsName);
}
return {
key: baseParts.join('||'),
itemSummary,
itemSnapshotKey,
itemDetails,
logisticsName,
};
}
/**
* 团购波次可抓取列表。
*
* 仅处理待处理订单(排除待审核),且排除已在波次中的订单。
*
* @param {Object} data 请求参数。
* @return {Promise<Object>} 抓取列表和分页信息。
*/
async groupOrderFetchList(data = {}) {
const t0 = Date.now();
const requestData = this.isPlainObject(data) ? data : {};
const warehouseId = this.getWarehouseId();
const model = await this.getOrderModel('pendingOrder', warehouseId);
const t1 = Date.now();
const distinguishExpress = this.normalizeBoolean(requestData.distinguish_express, false);
const storeId = this.normalizePositiveInteger(requestData.store_id, 'store_id', 0);
const sameOrderQuantityInput = requestData.same_order_quantity;
const hasSameOrderQuantityInput = !(sameOrderQuantityInput === undefined || sameOrderQuantityInput === null || sameOrderQuantityInput === '');
const explicitSameOrderQuantity = hasSameOrderQuantityInput
? this.normalizePositiveInteger(sameOrderQuantityInput, 'same_order_quantity', 0)
: 0;
const minGroupOrderFetchQuantity = await this.getMinGroupOrderFetchQuantity(warehouseId);
const sameOrderQuantity = explicitSameOrderQuantity > 0
? explicitSameOrderQuantity
: minGroupOrderFetchQuantity;
const shopName = this.normalizeShopName(requestData.shop_name);
const includeSku = this.normalizeSkuText(requestData.include_sku);
const returnOrderIds = this.normalizeBoolean(requestData.return_order_ids, false);
const { page, pageSize } = this.normalizePagination(requestData);
const where = {
step: { [Op.in]: [ 1, 2, 3 ] },
status: { [Op.ne]: 'cancel' },
outbound_status: { [Op.ne]: 'padding' },
wave_id: 0,
};
if (storeId > 0) {
where.store_id = storeId;
}
if (shopName) {
where.shop_nick = { [Op.like]: `%${shopName}%` };
}
// Phase 1: 主表全量查询,用 items_hash 做分组基准
const rawOrders = await model.findAll({
where,
attributes: [
'id', 'store_id', 'logistics_name',
'items_hash', 'items', 'items_total',
'post_status', 'pick_status', 'outbound_status', 'create_at',
],
raw: true,
order: [[ 'id', 'DESC' ]],
});
const t2 = Date.now();
// Phase 2: 纯内存粗分组,items_hash 相同即为同组,速度快
// coarseGroupMap: coarseKey -> { orders[] }
const coarseGroupMap = new Map();
for (const order of rawOrders) {
const coarseKey = this.buildCoarseGroupKey(order, distinguishExpress);
if (!coarseKey) {
continue;
}
if (!coarseGroupMap.has(coarseKey)) {
coarseGroupMap.set(coarseKey, { orders: [] });
}
coarseGroupMap.get(coarseKey).orders.push(order);
}
// 过滤最小阈值、排序
let groupEntries = Array.from(coarseGroupMap.entries());
groupEntries = groupEntries.filter(([ , g ]) => g.orders.length >= sameOrderQuantity);
groupEntries.sort(([ keyA, gA ], [ keyB, gB ]) => {
if (gB.orders.length !== gA.orders.length) {
return gB.orders.length - gA.orders.length;
}
return keyA.localeCompare(keyB);
});
const total = groupEntries.length;
const t3 = Date.now();
// Phase 3: 分页分组,只取当前页
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
const pageStart = (page - 1) * pageSize;
const pageGroupEntries = groupEntries.slice(pageStart, pageStart + pageSize);
// 收集当前页每组的代表订单 id(同组 items_hash 相同,只需一条快照即可)
const representativeIdPerGroup = new Map(); // coarseKey -> representativeOrderId
for (const [ coarseKey, g ] of pageGroupEntries) {
const repOrder = g.orders.find(o => Number(o.id) > 0);
if (repOrder) {
representativeIdPerGroup.set(coarseKey, Number(repOrder.id));
}
}
const pageOrderIds = Array.from(representativeIdPerGroup.values());
const t4 = Date.now();
// Phase 4: 仅查每组代表订单的明细(每页 20 条左右,大幅降低 IN 数量)
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
const orderItemRows = pageOrderIds.length > 0
? await orderItemsModel.findAll({
where: { order_id: { [Op.in]: pageOrderIds } },
attributes: [ 'order_id', 'plan_qty', 'stock_id', 'item_code', 'item_name', 'item_snapshot' ],
raw: true,
})
: [];
const t5 = Date.now();
// 构建明细索引
const orderItemsMap = new Map();
for (const row of orderItemRows) {
const orderId = Number(row && row.order_id);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
if (!orderItemsMap.has(orderId)) {
orderItemsMap.set(orderId, []);
}
orderItemsMap.get(orderId).push(row);
}
// Phase 5: 构建当前页响应,每组取一个代表订单的 item_snapshot 作为展示快照
const list = [];
for (const [ coarseKey, g ] of pageGroupEntries) {
// 同粗分组内 items_hash 相同,取该组的代表订单明细作为展示快照
const representativeId = representativeIdPerGroup.get(coarseKey);
const itemRows = representativeId ? (orderItemsMap.get(representativeId) || []) : [];
const itemDetails = this.mergeOrderItemDetails(itemRows);
// includeSku 精确过滤(页内应用,total 为粗分组数量)
if (!this.orderMatchesIncludeSku(itemDetails, includeSku)) {
continue;
}
const itemSummary = this.buildItemSummary(itemDetails);
const itemSnapshotKey = this.buildItemSnapshotKey(itemDetails);
if (!itemSummary || !itemSnapshotKey) {
continue;
}
const itemPartInfo = this.getOrderItemPart(g.orders[0] || {});
const logisticsName = String(g.orders[0].logistics_name || '').trim();
const itemDetailMachine = this.buildMachineStructureToken({
item_part_type: itemPartInfo.item_part_type,
item_part: itemPartInfo.item_part,
distinguish_express: distinguishExpress,
logistics_name: logisticsName,
item_snapshot_key: itemSnapshotKey,
});
const store_ids = [ ...new Set(
g.orders.map(o => Number(o.store_id || 0)).filter(id => id > 0)
) ];
let first_order_time = null;
let last_order_time = null;
let items_total = 0;
for (const o of g.orders) {
items_total += Number(o.items_total || 0);
if (!first_order_time || o.create_at < first_order_time) first_order_time = o.create_at;
if (!last_order_time || o.create_at > last_order_time) last_order_time = o.create_at;
}
list.push({
item_detail: itemSummary,
item_detail_machine: itemDetailMachine,
item_detail_machine_snapshot: itemSnapshotKey,
item_snapshot: itemDetails,
group: g.orders.length,
group_count: g.orders.length,
items_total,
store_id: store_ids.length === 1 ? store_ids[0] : 0,
store_ids,
logistics_name: logisticsName,
distinguish_express: distinguishExpress,
...(returnOrderIds ? { order_ids: g.orders.map(o => Number(o.id)) } : {}),
first_order_time,
last_order_time,
status_summary: this.buildStatusSummary(g.orders),
});
}
const t6 = Date.now();
this.ctx.logger.info('[wave.groupOrderFetchList] 链路耗时', {
warehouseId,
params: { distinguishExpress, storeId, sameOrderQuantity, shopName: shopName || null, includeSku: includeSku || null },
counts: {
rawOrders: rawOrders.length,
coarseGroups: coarseGroupMap.size,
filteredGroups: total,
pageOrderIds: pageOrderIds.length,
orderItemRows: orderItemRows.length,
pageItems: list.length,
},
timing_ms: {
getModel: t1 - t0,
queryOrders: t2 - t1,
coarseGrouping: t3 - t2,
pagination: t4 - t3,
queryItems: t5 - t4,
buildList: t6 - t5,
total: t6 - t0,
},
});
return this.success('ok', {
list,
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
/**
* 散单波次可抓取列表。
*
* 仅处理待处理订单(排除待审核),且排除已在波次中的订单。
* 与团购抓取共用同一链路,仅排除团购阈值命中的分组。
*
* @param {Object} data 请求参数。
* @return {Promise<Object>} 抓取列表和分页信息。
*/
async singleOrderFetchList(data = {}) {
const t0 = Date.now();
const requestData = this.isPlainObject(data) ? data : {};
const warehouseId = this.getWarehouseId();
const model = await this.getOrderModel('pendingOrder', warehouseId);
const t1 = Date.now();
const distinguishExpress = this.normalizeBoolean(requestData.distinguish_express, false);
const storeId = this.normalizePositiveInteger(requestData.store_id, 'store_id', 0);
const sameOrderQuantityInput = requestData.same_order_quantity;
const hasSameOrderQuantityInput = !(sameOrderQuantityInput === undefined || sameOrderQuantityInput === null || sameOrderQuantityInput === '');
const explicitSameOrderQuantity = hasSameOrderQuantityInput
? this.normalizePositiveInteger(sameOrderQuantityInput, 'same_order_quantity', 0)
: 0;
const minGroupOrderFetchQuantity = await this.getMinGroupOrderFetchQuantity(warehouseId);
const sameOrderQuantity = explicitSameOrderQuantity > 0
? explicitSameOrderQuantity
: minGroupOrderFetchQuantity;
const shopName = this.normalizeShopName(requestData.shop_name);
const includeSku = this.normalizeSkuText(requestData.include_sku);
const returnOrderIds = this.normalizeBoolean(requestData.return_order_ids, false);
const { page, pageSize } = this.normalizePagination(requestData);
const where = {
step: { [Op.in]: [ 1, 2, 3 ] },
status: { [Op.ne]: 'cancel' },
outbound_status: { [Op.ne]: 'padding' },
wave_id: 0,
};
if (storeId > 0) {
where.store_id = storeId;
}
if (shopName) {
where.shop_nick = { [Op.like]: `%${shopName}%` };
}
// Phase 1: 主表全量查询,用 items_hash 做分组基准
const rawOrders = await model.findAll({
where,
attributes: [
'id', 'store_id', 'logistics_name',
'items_hash', 'items', 'items_total',
'post_status', 'pick_status', 'outbound_status', 'create_at',
],
raw: true,
order: [[ 'id', 'DESC' ]],
});
const t2 = Date.now();
// Phase 2: 纯内存粗分组,items_hash 相同即为同组,速度快
// coarseGroupMap: coarseKey -> { orders[] }
const coarseGroupMap = new Map();
for (const order of rawOrders) {
const coarseKey = this.buildCoarseGroupKey(order, distinguishExpress);
if (!coarseKey) {
continue;
}
if (!coarseGroupMap.has(coarseKey)) {
coarseGroupMap.set(coarseKey, { orders: [] });
}
coarseGroupMap.get(coarseKey).orders.push(order);
}
// 过滤团购阈值(排除团购分组)、排序
let groupEntries = Array.from(coarseGroupMap.entries());
groupEntries = groupEntries.filter(([ , g ]) => g.orders.length < sameOrderQuantity);
groupEntries.sort(([ keyA, gA ], [ keyB, gB ]) => {
if (gB.orders.length !== gA.orders.length) {
return gB.orders.length - gA.orders.length;
}
return keyA.localeCompare(keyB);
});
const total = groupEntries.length;
const t3 = Date.now();
// Phase 3: 分页分组,只取当前页
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
const pageStart = (page - 1) * pageSize;
const pageGroupEntries = groupEntries.slice(pageStart, pageStart + pageSize);
// 收集当前页每组的代表订单 id(同组 items_hash 相同,只需一条快照即可)
const representativeIdPerGroup = new Map(); // coarseKey -> representativeOrderId
for (const [ coarseKey, g ] of pageGroupEntries) {
const repOrder = g.orders.find(o => Number(o.id) > 0);
if (repOrder) {
representativeIdPerGroup.set(coarseKey, Number(repOrder.id));
}
}
const pageOrderIds = Array.from(representativeIdPerGroup.values());
const t4 = Date.now();
// Phase 4: 仅查每组代表订单的明细(每页 20 条左右,大幅降低 IN 数量)
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
const orderItemRows = pageOrderIds.length > 0
? await orderItemsModel.findAll({
where: { order_id: { [Op.in]: pageOrderIds } },
attributes: [ 'order_id', 'plan_qty', 'stock_id', 'item_code', 'item_name', 'item_snapshot' ],
raw: true,
})
: [];
const t5 = Date.now();
// 构建明细索引
const orderItemsMap = new Map();
for (const row of orderItemRows) {
const orderId = Number(row && row.order_id);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
if (!orderItemsMap.has(orderId)) {
orderItemsMap.set(orderId, []);
}
orderItemsMap.get(orderId).push(row);
}
// Phase 5: 构建当前页响应,每组取一个代表订单的 item_snapshot 作为展示快照
const list = [];
for (const [ coarseKey, g ] of pageGroupEntries) {
// 同粗分组内 items_hash 相同,取该组的代表订单明细作为展示快照
const representativeId = representativeIdPerGroup.get(coarseKey);
const itemRows = representativeId ? (orderItemsMap.get(representativeId) || []) : [];
const itemDetails = this.mergeOrderItemDetails(itemRows);
// includeSku 精确过滤(页内应用,total 为粗分组数量)
if (!this.orderMatchesIncludeSku(itemDetails, includeSku)) {
continue;
}
const itemSummary = this.buildItemSummary(itemDetails);
const itemSnapshotKey = this.buildItemSnapshotKey(itemDetails);
if (!itemSummary || !itemSnapshotKey) {
continue;
}
const itemPartInfo = this.getOrderItemPart(g.orders[0] || {});
const logisticsName = String(g.orders[0].logistics_name || '').trim();
const itemDetailMachine = this.buildMachineStructureToken({
item_part_type: itemPartInfo.item_part_type,
item_part: itemPartInfo.item_part,
distinguish_express: distinguishExpress,
logistics_name: logisticsName,
item_snapshot_key: itemSnapshotKey,
});
const store_ids = [ ...new Set(
g.orders.map(o => Number(o.store_id || 0)).filter(id => id > 0)
) ];
let first_order_time = null;
let last_order_time = null;
let items_total = 0;
for (const o of g.orders) {
items_total += Number(o.items_total || 0);
if (!first_order_time || o.create_at < first_order_time) first_order_time = o.create_at;
if (!last_order_time || o.create_at > last_order_time) last_order_time = o.create_at;
}
list.push({
item_detail: itemSummary,
item_detail_machine: itemDetailMachine,
item_detail_machine_snapshot: itemSnapshotKey,
item_snapshot: itemDetails,
group: g.orders.length,
group_count: g.orders.length,
items_total,
store_id: store_ids.length === 1 ? store_ids[0] : 0,
store_ids,
logistics_name: logisticsName,
distinguish_express: distinguishExpress,
...(returnOrderIds ? { order_ids: g.orders.map(o => Number(o.id)) } : {}),
first_order_time,
last_order_time,
status_summary: this.buildStatusSummary(g.orders),
});
}
const t6 = Date.now();
this.ctx.logger.info('[wave.singleOrderFetchList] 链路耗时', {
warehouseId,
params: { distinguishExpress, storeId, sameOrderQuantity, shopName: shopName || null, includeSku: includeSku || null },
counts: {
rawOrders: rawOrders.length,
coarseGroups: coarseGroupMap.size,
filteredGroups: total,
pageOrderIds: pageOrderIds.length,
orderItemRows: orderItemRows.length,
pageItems: list.length,
},
timing_ms: {
getModel: t1 - t0,
queryOrders: t2 - t1,
coarseGrouping: t3 - t2,
pagination: t4 - t3,
queryItems: t5 - t4,
buildList: t6 - t5,
total: t6 - t0,
},
});
return this.success('ok', {
list,
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
/**
* 波次列表查询。
*
* 默认查询状态为 0/1 的波次,并附带订单分配状态汇总。
*
* @param {Object} data 请求参数。
* @param {Object} data.pagination 分页参数。
* @return {Promise<Object>} 波次列表及分页信息。
*/
async batchList(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const { page, pageSize } = this.normalizePagination(requestData, {
maxPageSize: BATCH_LIST_MAX_PAGE_SIZE,
});
const waveStatusList = [ 0, 1 ];
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const warehouseId = contextWarehouseId;
const offset = (page - 1) * pageSize;
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderTableName = this.getModelTableSqlName(orderModel);
const whereClause = this.buildBatchListWhereClause(requestData.where);
const storageAssignmentFilterClause = this.buildBatchListStorageAssignmentFilterClause(whereClause.storageAssignmentStatus);
const baseBatchWhereSql = `
warehouse_id = :warehouseId
AND wave_status IN (:waveStatusList)
${whereClause.sql}
`;
const batchListFromSql = `
FROM (
SELECT
wave_id,
wave_no,
wave_type,
wave_status,
total_orders,
processed_orders,
distinguish_express,
logistics_name,
item_snapshot_key,
warehouse_id,
creator,
create_time,
update_time
FROM wms_wave_batch
WHERE ${baseBatchWhereSql}
) wb
LEFT JOIN (
SELECT
candidate_wave.wave_id,
COUNT(od.wave_id) AS order_total,
SUM(CASE WHEN od.storage_status = 'none' THEN 1 ELSE 0 END) AS storage_none_count,
SUM(CASE WHEN od.storage_status = 'fin' THEN 1 ELSE 0 END) AS storage_fin_count,
SUM(CASE WHEN od.storage_status = 'error' THEN 1 ELSE 0 END) AS storage_error_count
FROM (
SELECT wave_id
FROM wms_wave_batch
WHERE ${baseBatchWhereSql}
) candidate_wave
LEFT JOIN ${orderTableName} od ON od.wave_id = candidate_wave.wave_id
GROUP BY candidate_wave.wave_id
) wave_order_stats ON wave_order_stats.wave_id = wb.wave_id
WHERE 1 = 1
${storageAssignmentFilterClause.sql}
`;
const listSql = `
SELECT
wb.wave_id,
wb.wave_no,
wb.wave_type,
wb.wave_status,
wb.total_orders,
wb.processed_orders,
wb.distinguish_express,
wb.logistics_name,
wb.item_snapshot_key,
wb.warehouse_id,
wb.creator,
wb.create_time,
wb.update_time
${batchListFromSql}
ORDER BY wb.total_orders DESC, wb.wave_id DESC
LIMIT :limit OFFSET :offset
`;
const countSql = `
SELECT COUNT(1) AS total
${batchListFromSql}
`;
const [ batchRows, totalRows ] = await Promise.all([
this.ctx.model.query(listSql, {
replacements: {
warehouseId,
waveStatusList,
...whereClause.replacements,
...storageAssignmentFilterClause.replacements,
limit: pageSize,
offset,
},
}),
this.ctx.model.query(countSql, {
replacements: {
warehouseId,
waveStatusList,
...whereClause.replacements,
...storageAssignmentFilterClause.replacements,
},
}),
]);
const rawList = Array.isArray(batchRows && batchRows[0]) ? batchRows[0] : [];
const totalRowList = Array.isArray(totalRows && totalRows[0]) ? totalRows[0] : [];
const total = Number(totalRowList[0] && totalRowList[0].total || 0);
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
if (rawList.length === 0) {
return this.success('ok', {
list: [],
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
const waveIds = rawList
.map(item => Number(item && item.wave_id || 0))
.filter(id => Number.isInteger(id) && id > 0);
const orderRows = waveIds.length > 0
? await orderModel.findAll({
where: {
wave_id: { [Op.in]: waveIds },
},
attributes: [ 'wave_id', 'storage_status', 'post_status', 'print_status' ],
raw: true,
})
: [];
const waveOrderStatsMap = new Map();
for (const row of orderRows) {
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
if (!waveOrderStatsMap.has(waveId)) {
waveOrderStatsMap.set(waveId, {
orderCount: 0,
storageNoneCount: 0,
storageFinCount: 0,
storageErrorCount: 0,
expressNoneCount: 0,
expressFinCount: 0,
expressErrorCount: 0,
printNoneCount: 0,
printFinCount: 0,
});
}
const stats = waveOrderStatsMap.get(waveId);
const storageStatus = String(row && row.storage_status || '').trim();
const expressStatus = String(row && row.post_status || '').trim();
const printStatus = String(row && row.print_status || '').trim();
stats.orderCount += 1;
if (storageStatus === 'none') {
stats.storageNoneCount += 1;
} else if (storageStatus === 'fin') {
stats.storageFinCount += 1;
} else if (storageStatus === 'error') {
stats.storageErrorCount += 1;
}
if (expressStatus === 'none') {
stats.expressNoneCount += 1;
} else if (expressStatus === 'fin') {
stats.expressFinCount += 1;
} else if (expressStatus === 'error') {
stats.expressErrorCount += 1;
}
if (printStatus === 'none') {
stats.printNoneCount += 1;
} else if (printStatus === 'fin') {
stats.printFinCount += 1;
}
}
const list = rawList.map(batch => {
const waveId = Number(batch && batch.wave_id || 0);
const stats = waveOrderStatsMap.get(waveId) || {};
const orderCount = Number(stats.orderCount || 0);
const storageNoneCount = Number(stats.storageNoneCount || 0);
const storageFinCount = Number(stats.storageFinCount || 0);
const storageErrorCount = Number(stats.storageErrorCount || 0);
const expressNoneCount = Number(stats.expressNoneCount || 0);
const expressFinCount = Number(stats.expressFinCount || 0);
const expressErrorCount = Number(stats.expressErrorCount || 0);
const printNoneCount = Number(stats.printNoneCount || 0);
const printFinCount = Number(stats.printFinCount || 0);
return {
wave_id: waveId,
wave_no: String(batch && batch.wave_no || '').trim(),
wave_type: Number(batch && batch.wave_type || 0),
wave_status: Number(batch && batch.wave_status || 0),
total_orders: Number(batch && batch.total_orders || 0),
processed_orders: Number(batch && batch.processed_orders || 0),
item_detail_machine: String(batch && batch.item_detail_machine || '').trim(),
item_part_type: String(batch && batch.item_part_type || '').trim(),
item_part: String(batch && batch.item_part || '').trim(),
distinguish_express: Number(batch && batch.distinguish_express || 0),
logistics_name: String(batch && batch.logistics_name || '').trim(),
item_snapshot_key: String(batch && batch.item_snapshot_key || '').trim(),
warehouse_id: Number(batch && batch.warehouse_id || 0),
creator: String(batch && batch.creator || '').trim(),
create_time: batch && batch.create_time || null,
update_time: batch && batch.update_time || null,
order_count: orderCount,
storage_assignment_status: this.resolveAssignmentStatus(orderCount, storageNoneCount, storageFinCount, storageErrorCount),
express_assignment_status: this.resolveAssignmentStatus(orderCount, expressNoneCount, expressFinCount, expressErrorCount),
print_assignment_status: this.resolveAssignmentStatus(orderCount, printNoneCount, printFinCount, 0, {
none: '未打印',
partial: '部分打印',
finished: '已打印',
}),
};
});
return this.success('ok', {
list,
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
/**
* 批量解除波次任务提交接口。
*
* 仅处理当前登录仓库下的波次与订单,提交后异步执行。
*
* @param {Object} data 请求参数。
* @param {number|string} [data.warehouse_id] 仓库ID(可选,若传入必须与当前上下文一致)。
* @param {number|string} [data.warehouseId] 仓库ID(驼峰写法)。
* @param {Array<number|string>|number|string} [data.wave_ids] 波次ID集合(下划线写法,优先)。
* @param {Array<number|string>|number|string} [data.waveIds] 波次ID集合(驼峰写法)。
* @param {Array<number|string>|number|string} [data.ids] 波次ID集合(兼容写法)。
* @param {string} [data.task_id] 外部指定任务ID(用于幂等提交)。
* @param {string} [data.taskId] 外部指定任务ID(驼峰写法)。
* @return {Promise<Object>} 任务提交结果。
*/
async batchCancel(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const requestWarehouseId = Number(data && (data.warehouse_id ?? data.warehouseId) || contextWarehouseId);
if (!Number.isInteger(requestWarehouseId) || requestWarehouseId <= 0) {
throw new Error('warehouse_id 参数不合法');
}
if (requestWarehouseId !== contextWarehouseId) {
throw new Error('warehouse_id 与当前仓库上下文不一致');
}
const warehouseId = requestWarehouseId;
const normalizedWaveIds = this.normalizeBatchCancelWaveIds(data);
if (normalizedWaveIds.length === 0) {
throw new Error('wave_ids 参数不能为空或格式错误');
}
const requestedTaskId = this.normalizeBatchCancelTaskId(data);
const taskId = requestedTaskId || this.generateBatchCancelTaskId(warehouseId);
const existingTask = await this.getBatchCancelTaskProgress(taskId);
if (existingTask) {
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: Number(existingTask.warehouse_id || warehouseId),
state: String(existingTask.state || 'submitted').trim() || 'submitted',
message: 'Batch cancel task already exists. Check progress with order.wave.batchCancelTaskProgress',
accepted_at: existingTask.accepted_at || existingTask.submitted_at || new Date().toISOString(),
});
}
const acceptedAt = new Date().toISOString();
await this.setBatchCancelTaskProgress(taskId, 'submitted', {
warehouse_id: warehouseId,
wave_ids: normalizedWaveIds.join(','),
wave_id_list: normalizedWaveIds,
total_wave_count: normalizedWaveIds.length,
processed_wave_count: 0,
progress_percent: 0,
submitted_at: Date.now(),
accepted_at: acceptedAt,
result: null,
error: '',
error_code: '',
});
this.ctx.logger.info('[wave.batchCancel] 任务提交成功', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
});
setImmediate(() => {
this.runBatchCancelTask({
taskId,
warehouseId,
waveIds: normalizedWaveIds,
}).catch(error => {
this.ctx.logger.error('[wave.batchCancel] 后台任务异常', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
error: error && error.message ? error.message : error,
stack: error && error.stack ? error.stack : '',
});
});
});
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: warehouseId,
message: 'Batch cancel submitted. Check progress with order.wave.batchCancelTaskProgress',
accepted_at: acceptedAt,
});
}
/**
* 查询批量解除波次任务进度。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {Promise<Object>} 任务进度响应。
*/
async batchCancelTaskProgress(data = {}) {
const taskId = this.normalizeBatchCancelTaskId(data);
if (!taskId) {
return this.fail('task_id 参数不能为空', 400);
}
const cachedProgress = await this.getBatchCancelTaskProgress(taskId);
if (!cachedProgress) {
return this.success('ok', {
task_id: taskId,
state: 'not_found',
});
}
const state = String(cachedProgress.state || 'submitted').trim() || 'submitted';
const payload = {
task_id: taskId,
state,
warehouse_id: Number(cachedProgress.warehouse_id || 0),
submitted_at: cachedProgress.submitted_at || null,
start_time: cachedProgress.start_time || null,
end_time: cachedProgress.end_time || null,
};
if (state === 'submitted' || state === 'running') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.processed_wave_count = Number(cachedProgress.processed_wave_count || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
}
if (state === 'success') {
const result = this.isPlainObject(cachedProgress.result) ? cachedProgress.result : {};
payload.progress_percent = Number(cachedProgress.progress_percent || 100);
payload.affected_wave_ids = Array.isArray(result.affected_wave_ids) ? result.affected_wave_ids : [];
payload.affected_order_count = Number(result.affected_order_count || 0);
payload.canceled_wave_count = Number(result.canceled_wave_count || 0);
payload.duration_ms = Number(result.duration_ms || cachedProgress.duration_ms || 0);
}
if (state === 'failed') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.error_message = String(cachedProgress.error || '').trim();
payload.error_code = String(cachedProgress.error_code || '').trim() || 'WAVE_BATCH_CANCEL_FAILED';
payload.failed_wave_id = Number(cachedProgress.failed_wave_id || 0);
payload.failed_wave_no = String(cachedProgress.failed_wave_no || '').trim();
payload.duration_ms = Number(cachedProgress.duration_ms || 0);
}
return this.success('ok', payload);
}
/**
* 批次分配快递号任务提交接口。
*
* 仅接收当前仓库下波次ID,提交后立即返回 task_id,实际分配由后台异步执行。
*
* @param {Object} data 请求参数。
* @param {number|string} [data.warehouse_id] 仓库ID(可选,若传入必须与当前上下文一致)。
* @param {number|string} [data.warehouseId] 仓库ID(驼峰写法)。
* @param {Array<number|string>|number|string} [data.wave_ids] 波次ID集合(下划线写法,优先)。
* @param {Array<number|string>|number|string} [data.waveIds] 波次ID集合(驼峰写法)。
* @param {Array<number|string>|number|string} [data.ids] 波次ID集合(兼容写法)。
* @param {string} [data.task_id] 外部指定任务ID(用于幂等提交)。
* @param {string} [data.taskId] 外部指定任务ID(驼峰写法)。
* @return {Promise<Object>} 任务受理结果。
*/
async batchAllocateExpress(data = {}) {
const traceId = this.buildBatchAllocateExpressTraceId(data);
const requestSnapshot = {
warehouse_id: data && (data.warehouse_id ?? data.warehouseId),
wave_ids: data && (data.wave_ids ?? data.waveIds ?? data.ids),
task_id: data && (data.task_id ?? data.taskId),
};
this.ctx.logger.info('[wave.batchAllocateExpress] 入口请求', {
traceId,
requestSnapshot,
});
try {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 参数校验失败-仓库上下文缺失', {
traceId,
contextWarehouseId,
requestSnapshot,
});
throw new Error('未识别到当前仓库上下文');
}
const requestWarehouseId = Number(data && (data.warehouse_id ?? data.warehouseId) || contextWarehouseId);
if (!Number.isInteger(requestWarehouseId) || requestWarehouseId <= 0) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 参数校验失败-warehouse_id 非法', {
traceId,
contextWarehouseId,
requestWarehouseId,
requestSnapshot,
});
throw new Error('warehouse_id 参数不合法');
}
if (requestWarehouseId !== contextWarehouseId) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 参数校验失败-warehouse_id 与上下文不一致', {
traceId,
contextWarehouseId,
requestWarehouseId,
requestSnapshot,
});
throw new Error('warehouse_id 与当前仓库上下文不一致');
}
const warehouseId = requestWarehouseId;
const normalizedWaveIds = this.normalizeBatchAllocateExpressWaveIds(data);
if (normalizedWaveIds.length === 0) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 参数校验失败-wave_ids 为空', {
traceId,
warehouseId,
requestSnapshot,
});
throw new Error('wave_ids 参数不能为空或格式错误');
}
const requestedTaskId = this.normalizeBatchAllocateExpressTaskId(data);
const taskId = requestedTaskId || this.generateBatchAllocateExpressTaskId(warehouseId);
const existingTask = await this.getBatchAllocateExpressTaskProgress(taskId);
if (existingTask) {
this.ctx.logger.info('[wave.batchAllocateExpress] 命中幂等任务缓存,直接返回', {
traceId,
taskId,
warehouseId,
waveIds: normalizedWaveIds,
cachedState: String(existingTask.state || '').trim() || 'submitted',
});
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: Number(existingTask.warehouse_id || warehouseId),
state: String(existingTask.state || 'submitted').trim() || 'submitted',
message: 'Batch allocate express task already exists. Check progress with order.wave.batchAllocateExpressTaskProgress',
accepted_at: existingTask.accepted_at || existingTask.submitted_at || new Date().toISOString(),
});
}
const acceptedAt = new Date().toISOString();
await this.setBatchAllocateExpressTaskProgress(taskId, 'submitted', {
warehouse_id: warehouseId,
wave_ids: normalizedWaveIds.join(','),
wave_id_list: normalizedWaveIds,
total_wave_count: normalizedWaveIds.length,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
progress_percent: 0,
submitted_at: Date.now(),
accepted_at: acceptedAt,
result: null,
error: '',
error_code: '',
trace_id: traceId,
});
this.ctx.logger.info('[wave.batchAllocateExpress] 任务提交成功', {
traceId,
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
waveIds: normalizedWaveIds,
});
setImmediate(() => {
this.runBatchAllocateExpressTask({
taskId,
warehouseId,
waveIds: normalizedWaveIds,
trace_id: traceId,
}).catch(error => {
this.ctx.logger.error('[wave.batchAllocateExpress] 后台任务异常', {
traceId,
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
error: error && error.message ? error.message : error,
stack: error && error.stack ? error.stack : '',
});
});
});
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: warehouseId,
message: 'Batch allocate express submitted. Check progress with order.wave.batchAllocateExpressTaskProgress',
accepted_at: acceptedAt,
});
} catch (error) {
this.ctx.logger.error('[wave.batchAllocateExpress] 入口处理异常', {
traceId,
requestSnapshot,
error: error && error.message ? error.message : `${error}`,
stack: error && error.stack ? error.stack : '',
});
throw error;
}
}
/**
* 查询批次分配快递号任务进度。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {Promise<Object>} 任务进度响应。
*/
async batchAllocateExpressTaskProgress(data = {}) {
const taskId = this.normalizeBatchAllocateExpressTaskId(data);
if (!taskId) {
return this.fail('task_id 参数不能为空', 400);
}
const cachedProgress = await this.getBatchAllocateExpressTaskProgress(taskId);
if (!cachedProgress) {
return this.success('ok', {
task_id: taskId,
state: 'not_found',
});
}
const state = String(cachedProgress.state || 'submitted').trim() || 'submitted';
const payload = {
task_id: taskId,
state,
warehouse_id: Number(cachedProgress.warehouse_id || 0),
submitted_at: cachedProgress.submitted_at || null,
start_time: cachedProgress.start_time || null,
end_time: cachedProgress.end_time || null,
};
if (state === 'submitted' || state === 'running') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
}
if (state === 'success') {
const result = this.isPlainObject(cachedProgress.result) ? cachedProgress.result : {};
payload.progress_percent = Number(cachedProgress.progress_percent || 100);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.success_order_count = Number(cachedProgress.success_order_count || 0);
payload.failed_order_count = Number(cachedProgress.failed_order_count || 0);
payload.allocated_order_count = Number(result.allocated_order_count || 0);
payload.duration_ms = Number(result.duration_ms || cachedProgress.duration_ms || 0);
payload.message = String(result.message || '').trim();
}
if (state === 'failed') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.success_order_count = Number(cachedProgress.success_order_count || 0);
payload.failed_order_count = Number(cachedProgress.failed_order_count || 0);
payload.error_message = String(cachedProgress.error || '').trim();
payload.error_code = String(cachedProgress.error_code || '').trim() || 'WAVE_BATCH_ALLOCATE_EXPRESS_FAILED';
payload.duration_ms = Number(cachedProgress.duration_ms || 0);
}
return this.success('ok', payload);
}
/**
* 批次分配储位任务提交接口。
*
* 仅接收当前仓库下波次ID,提交后立即返回 task_id,实际分配由后台异步执行。
*
* @param {Object} data 请求参数。
* @param {number|string} [data.warehouse_id] 仓库ID(可选,若传入必须与当前上下文一致)。
* @param {number|string} [data.warehouseId] 仓库ID(驼峰写法)。
* @param {Array<number|string>|number|string} [data.wave_ids] 波次ID集合(下划线写法,优先)。
* @param {Array<number|string>|number|string} [data.waveIds] 波次ID集合(驼峰写法)。
* @param {Array<number|string>|number|string} [data.ids] 波次ID集合(兼容写法)。
* @param {string} [data.task_id] 外部指定任务ID(用于幂等提交)。
* @param {string} [data.taskId] 外部指定任务ID(驼峰写法)。
* @return {Promise<Object>} 任务受理结果。
*/
async batchAllocateStorage(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const requestWarehouseId = Number(data && (data.warehouse_id ?? data.warehouseId) || contextWarehouseId);
if (!Number.isInteger(requestWarehouseId) || requestWarehouseId <= 0) {
throw new Error('warehouse_id 参数不合法');
}
if (requestWarehouseId !== contextWarehouseId) {
throw new Error('warehouse_id 与当前仓库上下文不一致');
}
const warehouseId = requestWarehouseId;
const normalizedWaveIds = this.normalizeBatchAllocateStorageWaveIds(data);
if (normalizedWaveIds.length === 0) {
throw new Error('wave_ids 参数不能为空或格式错误');
}
const requestedTaskId = this.normalizeBatchAllocateStorageTaskId(data);
const taskId = requestedTaskId || this.generateBatchAllocateStorageTaskId(warehouseId);
const existingTask = await this.getBatchAllocateStorageTaskProgress(taskId);
if (existingTask) {
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: Number(existingTask.warehouse_id || warehouseId),
state: String(existingTask.state || 'submitted').trim() || 'submitted',
message: 'Batch allocate storage task already exists. Check progress with order.wave.batchAllocateStorageTaskProgress',
accepted_at: existingTask.accepted_at || existingTask.submitted_at || new Date().toISOString(),
});
}
const acceptedAt = new Date().toISOString();
await this.setBatchAllocateStorageTaskProgress(taskId, 'submitted', {
warehouse_id: warehouseId,
wave_ids: normalizedWaveIds.join(','),
wave_id_list: normalizedWaveIds,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
total_wave_count: normalizedWaveIds.length,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
progress_percent: 0,
submitted_at: Date.now(),
accepted_at: acceptedAt,
result: null,
error: '',
error_code: '',
});
this.ctx.logger.info('[wave.batchAllocateStorage] 任务提交成功', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
});
setImmediate(() => {
this.runBatchAllocateStorageTask({
taskId,
warehouseId,
waveIds: normalizedWaveIds,
}).catch(error => {
this.ctx.logger.error('[wave.batchAllocateStorage] 后台任务异常', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
error: error && error.message ? error.message : error,
stack: error && error.stack ? error.stack : '',
});
});
});
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: warehouseId,
message: 'Batch allocate storage submitted. Check progress with order.wave.batchAllocateStorageTaskProgress',
accepted_at: acceptedAt,
});
}
/**
* 查询批次分配储位任务进度。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {Promise<Object>} 任务进度响应。
*/
async batchAllocateStorageTaskProgress(data = {}) {
const taskId = this.normalizeBatchAllocateStorageTaskId(data);
if (!taskId) {
return this.fail('task_id 参数不能为空', 400);
}
const cachedProgress = await this.getBatchAllocateStorageTaskProgress(taskId);
if (!cachedProgress) {
return this.success('ok', {
task_id: taskId,
state: 'not_found',
});
}
const state = String(cachedProgress.state || 'submitted').trim() || 'submitted';
const payload = {
task_id: taskId,
state,
warehouse_id: Number(cachedProgress.warehouse_id || 0),
submitted_at: cachedProgress.submitted_at || null,
start_time: cachedProgress.start_time || null,
end_time: cachedProgress.end_time || null,
};
const cachedBusinessId = Number(cachedProgress.business_id || 0);
const cachedBusinessIds = this.normalizeIdsInput(cachedProgress.business_ids);
if (cachedBusinessId > 0) {
payload.business_id = cachedBusinessId;
}
if (cachedBusinessIds.length > 0) {
payload.business_ids = cachedBusinessIds;
}
if (state === 'submitted' || state === 'running') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
}
if (state === 'success') {
const result = this.isPlainObject(cachedProgress.result) ? cachedProgress.result : {};
payload.progress_percent = Number(cachedProgress.progress_percent || 100);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.success_order_count = Number(cachedProgress.success_order_count || 0);
payload.failed_order_count = Number(cachedProgress.failed_order_count || 0);
payload.allocated_order_count = Number(result.allocated_order_count || cachedProgress.allocated_order_count || 0);
payload.affected_order_count = Number(result.affected_order_count || cachedProgress.affected_order_count || 0);
payload.allocated_order_ids = this.normalizeIdsInput(
result.allocated_order_ids !== undefined
? result.allocated_order_ids
: cachedProgress.allocated_order_ids
);
payload.shortage_order_ids = this.normalizeIdsInput(
result.shortage_order_ids !== undefined
? result.shortage_order_ids
: cachedProgress.shortage_order_ids
);
payload.affected_order_ids = this.normalizeIdsInput(
result.affected_order_ids !== undefined
? result.affected_order_ids
: cachedProgress.affected_order_ids
);
const successBusinessId = Number(result.business_id || payload.business_id || 0);
const successBusinessIds = this.normalizeIdsInput(
result.business_ids !== undefined
? result.business_ids
: payload.business_ids
);
if (successBusinessId > 0) {
payload.business_id = successBusinessId;
}
if (successBusinessIds.length > 0) {
payload.business_ids = successBusinessIds;
}
payload.duration_ms = Number(result.duration_ms || cachedProgress.duration_ms || 0);
payload.message = String(result.message || '').trim();
}
if (state === 'failed') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.success_order_count = Number(cachedProgress.success_order_count || 0);
payload.failed_order_count = Number(cachedProgress.failed_order_count || 0);
payload.error_message = String(cachedProgress.error || '').trim();
payload.error_code = String(cachedProgress.error_code || '').trim() || 'WAVE_BATCH_ALLOCATE_STORAGE_FAILED';
payload.duration_ms = Number(cachedProgress.duration_ms || 0);
}
return this.success('ok', payload);
}
/**
* 批量将订单从波次中移出。
*
* 仅处理当前仓库待处理订单中 step in [1,2,3] 且已分配波次(wave_id>0)的订单。
* 全流程使用事务,确保订单更新与波次统计回写一致。
*
* @param {Object} data 请求参数。
* @param {Array<number|string>|number|string} data.ids 订单ID集合(优先)。
* @param {Array<number|string>|number|string} data.order_ids 订单ID集合别名。
* @param {Array<number|string>|number|string} data.orderIds 订单ID集合别名。
* @param {Array<number|string>|number|string} data.order_id 订单ID集合别名。
* @param {Array<number|string>|number|string} data.orderId 订单ID集合别名。
* @param {Array<number|string>|number|string} data.id 订单ID集合别名。
* @return {Promise<Object>} 批量移出结果。
*/
async batchRemoveOrders(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const warehouseId = contextWarehouseId;
const rawIds = data && (
data.ids !== undefined ? data.ids
: data.order_ids !== undefined ? data.order_ids
: data.orderIds !== undefined ? data.orderIds
: data.order_id !== undefined ? data.order_id
: data.orderId !== undefined ? data.orderId
: data.id
);
const normalizedIds = this.normalizeIdsInput(rawIds);
if (normalizedIds.length === 0) {
throw new Error('ids 参数不能为空或格式错误');
}
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const transaction = await this.ctx.model.transaction();
try {
const removableRows = await orderModel.findAll({
attributes: [ 'id', 'wave_id', 'wave_no' ],
where: {
id: { [Op.in]: normalizedIds },
step: { [Op.in]: [ 1, 2, 3 ] },
wave_id: { [Op.gt]: 0 },
},
raw: true,
transaction,
});
const removableOrderRows = Array.isArray(removableRows) ? removableRows : [];
const removablePendingIds = [ ...new Set(removableOrderRows
.map(row => Number(row && row.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
const removedOrderIds = [ ...new Set(removablePendingIds) ];
const affectedWaveIds = [ ...new Set(removableOrderRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
const removeOrderLogItems = removableOrderRows
.map(row => {
const orderId = Number(row && row.id || 0);
const waveNo = String(row && row.wave_no || '').trim() || '未知波次';
if (!Number.isInteger(orderId) || orderId <= 0) {
return null;
}
return {
orderId,
operationCode: 'ORDER_WAVE_REMOVE',
message: `订单从波次 ${waveNo} 中移除`,
};
})
.filter(Boolean);
if (removablePendingIds.length === 0 || affectedWaveIds.length === 0) {
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
removed_order_ids: [],
removed_order_count: 0,
affected_wave_ids: [],
updated_wave_ids: [],
emptied_wave_ids: [],
});
}
const orderUpdateResult = await orderModel.update({
wave_id: 0,
wave_no: '',
}, {
where: {
id: { [Op.in]: removablePendingIds },
},
transaction,
});
const updatedOrderCount = Number(Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0);
const remainingRows = await orderModel.findAll({
attributes: [
'wave_id',
[ this.ctx.model.fn('COUNT', this.ctx.model.col('id')), 'remaining_count' ],
],
where: {
wave_id: {
[Op.in]: affectedWaveIds,
[Op.gt]: 0,
},
},
group: [ 'wave_id' ],
raw: true,
transaction,
});
const remainingCountMap = new Map();
for (const row of (Array.isArray(remainingRows) ? remainingRows : [])) {
const waveId = Number(row && row.wave_id || 0);
const remainingCount = Number(row && row.remaining_count || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
remainingCountMap.set(waveId, Number.isInteger(remainingCount) && remainingCount > 0 ? remainingCount : 0);
}
const updatedWaveIds = [];
const emptiedWaveIds = [];
for (const waveId of affectedWaveIds) {
const remainingCount = Number(remainingCountMap.get(waveId) || 0);
if (remainingCount > 0) {
updatedWaveIds.push(waveId);
} else {
emptiedWaveIds.push(waveId);
}
}
for (const waveId of updatedWaveIds) {
const remainingCount = Number(remainingCountMap.get(waveId) || 0);
const updateWaveSql = `
UPDATE wms_wave_batch
SET total_orders = :remainingCount,
processed_orders = LEAST(processed_orders, :remainingCount),
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id = :waveId
`;
await this.ctx.model.query(updateWaveSql, {
replacements: {
warehouseId,
waveId,
remainingCount,
},
transaction,
});
}
if (emptiedWaveIds.length > 0) {
const emptyWaveSql = `
UPDATE wms_wave_batch
SET total_orders = 0,
processed_orders = 0,
wave_status = -1,
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
`;
await this.ctx.model.query(emptyWaveSql, {
replacements: {
warehouseId,
waveIds: emptiedWaveIds,
},
transaction,
});
}
await transaction.commit();
await this.batchCreateOrderOperationLogs(removeOrderLogItems, {
warehouseId,
scene: 'batchRemoveOrders',
});
return this.success('ok', {
ids: normalizedIds,
removed_order_ids: removedOrderIds,
removed_order_count: Number.isInteger(updatedOrderCount) && updatedOrderCount > 0 ? updatedOrderCount : 0,
affected_wave_ids: affectedWaveIds,
updated_wave_ids: updatedWaveIds,
emptied_wave_ids: emptiedWaveIds,
});
} catch (error) {
await transaction.rollback();
throw error;
}
}
/**
* 批量移除异常订单任务提交接口。
*
* 仅处理当前登录仓库下命中波次中的异常订单,提交后异步执行。
* 异常判定与订单模块待处理异常定义保持一致:仅 step=3。
* 实际移除动作复用既有 batchRemoveOrders 流水线,不重复实现解绑逻辑。
*
* @param {Object} data 请求参数。
* @param {number|string} [data.warehouse_id] 仓库ID(可选,若传入必须与当前上下文一致)。
* @param {number|string} [data.warehouseId] 仓库ID(驼峰写法)。
* @param {Array<number|string>|number|string} [data.wave_ids] 波次ID集合(下划线写法,优先)。
* @param {Array<number|string>|number|string} [data.waveIds] 波次ID集合(驼峰写法)。
* @param {Array<number|string>|number|string} [data.ids] 波次ID集合(兼容写法)。
* @param {string} [data.task_id] 外部指定任务ID(用于幂等提交)。
* @param {string} [data.taskId] 外部指定任务ID(驼峰写法)。
* @return {Promise<Object>} 任务提交结果。
*/
async batchRemoveExceptionOrders(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const requestWarehouseId = Number(data && (data.warehouse_id ?? data.warehouseId) || contextWarehouseId);
if (!Number.isInteger(requestWarehouseId) || requestWarehouseId <= 0) {
throw new Error('warehouse_id 参数不合法');
}
if (requestWarehouseId !== contextWarehouseId) {
throw new Error('warehouse_id 与当前仓库上下文不一致');
}
const warehouseId = requestWarehouseId;
const normalizedWaveIds = this.normalizeBatchRemoveExceptionOrdersWaveIds(data);
if (normalizedWaveIds.length === 0) {
throw new Error('wave_ids 参数不能为空或格式错误');
}
const requestedTaskId = this.normalizeBatchRemoveExceptionOrdersTaskId(data);
const taskId = requestedTaskId || this.generateBatchRemoveExceptionOrdersTaskId(warehouseId);
const existingTask = await this.getBatchRemoveExceptionOrdersTaskProgress(taskId);
if (existingTask) {
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: Number(existingTask.warehouse_id || warehouseId),
state: String(existingTask.state || 'submitted').trim() || 'submitted',
message: 'Batch remove exception orders task already exists. Check progress with order.wave.batchRemoveExceptionOrdersTaskProgress',
accepted_at: existingTask.accepted_at || existingTask.submitted_at || new Date().toISOString(),
});
}
const acceptedAt = new Date().toISOString();
await this.setBatchRemoveExceptionOrdersTaskProgress(taskId, 'submitted', {
warehouse_id: warehouseId,
wave_ids: normalizedWaveIds.join(','),
wave_id_list: normalizedWaveIds,
total_wave_count: normalizedWaveIds.length,
processed_wave_count: 0,
total_order_count: 0,
processed_order_count: 0,
removed_order_count: 0,
progress_percent: 0,
submitted_at: Date.now(),
accepted_at: acceptedAt,
result: null,
error: '',
error_code: '',
});
this.ctx.logger.info('[wave.batchRemoveExceptionOrders] 任务提交成功', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
});
setImmediate(() => {
this.runBatchRemoveExceptionOrdersTask({
taskId,
warehouseId,
waveIds: normalizedWaveIds,
}).catch(error => {
this.ctx.logger.error('[wave.batchRemoveExceptionOrders] 后台任务异常', {
taskId,
warehouseId,
waveCount: normalizedWaveIds.length,
error: error && error.message ? error.message : error,
stack: error && error.stack ? error.stack : '',
});
});
});
return this.success('ok', {
status: 'success',
task_id: taskId,
warehouse_id: warehouseId,
message: 'Batch remove exception orders submitted. Check progress with order.wave.batchRemoveExceptionOrdersTaskProgress',
accepted_at: acceptedAt,
});
}
/**
* 查询批量移除异常订单任务进度。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {Promise<Object>} 任务进度响应。
*/
async batchRemoveExceptionOrdersTaskProgress(data = {}) {
const taskId = this.normalizeBatchRemoveExceptionOrdersTaskId(data);
if (!taskId) {
return this.fail('task_id 参数不能为空', 400);
}
const cachedProgress = await this.getBatchRemoveExceptionOrdersTaskProgress(taskId);
if (!cachedProgress) {
return this.success('ok', {
task_id: taskId,
state: 'not_found',
});
}
const state = String(cachedProgress.state || 'submitted').trim() || 'submitted';
const payload = {
task_id: taskId,
state,
warehouse_id: Number(cachedProgress.warehouse_id || 0),
submitted_at: cachedProgress.submitted_at || null,
start_time: cachedProgress.start_time || null,
end_time: cachedProgress.end_time || null,
};
if (state === 'submitted' || state === 'running') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.processed_wave_count = Number(cachedProgress.processed_wave_count || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.removed_order_count = Number(cachedProgress.removed_order_count || 0);
}
if (state === 'success') {
const result = this.isPlainObject(cachedProgress.result) ? cachedProgress.result : {};
payload.progress_percent = Number(cachedProgress.progress_percent || 100);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.processed_wave_count = Number(cachedProgress.processed_wave_count || 0);
payload.total_order_count = Number(result.total_order_count || 0);
payload.processed_order_count = Number(result.processed_order_count || 0);
payload.removed_order_count = Number(result.removed_order_count || 0);
payload.removed_order_ids = Array.isArray(result.removed_order_ids) ? result.removed_order_ids : [];
payload.affected_wave_ids = Array.isArray(result.affected_wave_ids) ? result.affected_wave_ids : [];
payload.updated_wave_ids = Array.isArray(result.updated_wave_ids) ? result.updated_wave_ids : [];
payload.emptied_wave_ids = Array.isArray(result.emptied_wave_ids) ? result.emptied_wave_ids : [];
payload.duration_ms = Number(result.duration_ms || cachedProgress.duration_ms || 0);
}
if (state === 'failed') {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_wave_count = Number(cachedProgress.total_wave_count || 0);
payload.processed_wave_count = Number(cachedProgress.processed_wave_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.removed_order_count = Number(cachedProgress.removed_order_count || 0);
payload.error_message = String(cachedProgress.error || '').trim();
payload.error_code = String(cachedProgress.error_code || '').trim() || 'WAVE_BATCH_REMOVE_EXCEPTION_ORDERS_FAILED';
payload.failed_wave_id = Number(cachedProgress.failed_wave_id || 0);
payload.failed_wave_no = String(cachedProgress.failed_wave_no || '').trim();
payload.duration_ms = Number(cachedProgress.duration_ms || 0);
}
return this.success('ok', payload);
}
/**
* 生成可追踪的批量取消任务ID。
*
* 格式:wave_cancel_{warehouseId}_{timestamp}_{rand}。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 任务ID。
*/
generateBatchCancelTaskId(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: 0;
const timestamp = Math.floor(Date.now() / 1000);
const randomPart = Math.random().toString(36).slice(2, 6);
return `wave_cancel_${safeWarehouseId}_${timestamp}_${randomPart}`;
}
/**
* 归一化批量取消任务ID。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {string} 归一化后的任务ID。
*/
normalizeBatchCancelTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 生成可追踪的批量移除异常订单任务ID。
*
* 格式:wave_remove_exception_orders_{warehouseId}_{timestamp}_{rand}。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 任务ID。
*/
generateBatchRemoveExceptionOrdersTaskId(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: 0;
const timestamp = Math.floor(Date.now() / 1000);
const randomPart = Math.random().toString(36).slice(2, 6);
return `wave_remove_exception_orders_${safeWarehouseId}_${timestamp}_${randomPart}`;
}
/**
* 归一化批量移除异常订单任务ID。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {string} 归一化后的任务ID。
*/
normalizeBatchRemoveExceptionOrdersTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 归一化批量移除异常订单的波次ID参数。
*
* @param {Object} data 请求参数。
* @return {Array<number>} 归一化后的波次ID数组。
*/
normalizeBatchRemoveExceptionOrdersWaveIds(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
const rawWaveIds = normalizedData.wave_ids !== undefined
? normalizedData.wave_ids
: normalizedData.waveIds !== undefined
? normalizedData.waveIds
: normalizedData.ids !== undefined
? normalizedData.ids
: normalizedData.wave_id !== undefined
? normalizedData.wave_id
: normalizedData.waveId;
return this.normalizeIdsInput(rawWaveIds);
}
/**
* 获取批量移除异常订单任务缓存键。
*
* @param {string} taskId 任务ID。
* @return {string} 缓存键。
*/
getBatchRemoveExceptionOrdersTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${BATCH_REMOVE_EXCEPTION_ORDERS_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入批量移除异常订单任务进度缓存。
*
* @param {string} taskId 任务ID。
* @param {string} status 任务状态(submitted|running|success|failed)。
* @param {Object} data 进度或结果数据。
* @return {Promise<void>} 无返回值。
*/
async setBatchRemoveExceptionOrdersTaskProgress(taskId = '', status = 'submitted', data = {}) {
const cacheKey = this.getBatchRemoveExceptionOrdersTaskCacheKey(taskId);
if (!cacheKey) {
return;
}
const safeData = this.isPlainObject(data) ? data : {};
const mergedPayload = {
...(await this.getBatchRemoveExceptionOrdersTaskProgress(taskId) || {}),
...safeData,
task_id: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, mergedPayload, BATCH_REMOVE_EXCEPTION_ORDERS_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[wave.batchRemoveExceptionOrders] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取批量移除异常订单任务进度缓存。
*
* @param {string} taskId 任务ID。
* @return {Promise<Object|null>} 缓存对象。
*/
async getBatchRemoveExceptionOrdersTaskProgress(taskId = '') {
const cacheKey = this.getBatchRemoveExceptionOrdersTaskCacheKey(taskId);
if (!cacheKey) {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
this.ctx.logger.warn('[wave.batchRemoveExceptionOrders] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
/**
* 判断订单是否属于异常可移除范围。
*
* 与订单模块“待处理异常”语义保持一致:仅 step=3。
*
* @param {Object} row 订单行数据。
* @return {boolean} 是否为异常可移除订单。
*/
isExceptionRemovableOrder(row = {}) {
const step = Number(row && row.step || 0);
return step === 3;
}
/**
* 执行批量移除异常订单后台任务。
*
* 先按波次聚合异常订单,再复用 batchRemoveOrders 流水线执行解绑与波次统计回写。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
* @param {number|string} [params.warehouseId] 仓库ID(兜底)。
* @param {Array<number|string>|number|string} [params.waveIds] 波次ID集合(兜底)。
* @return {Promise<void>} 无返回值。
*/
async runBatchRemoveExceptionOrdersTask(params = {}) {
const normalizedTaskId = String(params && params.taskId || '').trim();
if (!normalizedTaskId) {
throw new Error('taskId 不能为空');
}
const cachedTask = await this.getBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId);
const warehouseId = Number(
cachedTask && cachedTask.warehouse_id !== undefined
? cachedTask.warehouse_id
: params && params.warehouseId
);
const waveIds = this.normalizeIdsInput(
cachedTask && cachedTask.wave_ids !== undefined
? cachedTask.wave_ids
: params && params.waveIds
);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'failed', {
end_time: Date.now(),
error: 'warehouse_id 参数不合法',
error_code: 'INVALID_WAREHOUSE_ID',
});
return;
}
if (waveIds.length === 0) {
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
end_time: Date.now(),
error: 'wave_ids 参数不能为空或格式错误',
error_code: 'INVALID_WAVE_IDS',
});
return;
}
const startTime = Date.now();
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
wave_ids: waveIds.join(','),
wave_id_list: waveIds,
total_wave_count: waveIds.length,
processed_wave_count: 0,
total_order_count: 0,
processed_order_count: 0,
removed_order_count: 0,
progress_percent: 0,
start_time: startTime,
end_time: null,
result: null,
error: '',
error_code: '',
failed_wave_id: 0,
failed_wave_no: '',
});
try {
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderRows = await orderModel.findAll({
attributes: [ 'id', 'wave_id', 'wave_no', 'step' ],
where: {
warehouse_id: warehouseId,
wave_id: {
[Op.in]: waveIds,
},
step: {
[Op.in]: [ 1, 2, 3 ],
},
},
raw: true,
});
const waveInfoById = new Map();
const exceptionOrderIds = [];
for (const row of (Array.isArray(orderRows) ? orderRows : [])) {
const orderId = Number(row && row.id || 0);
const waveId = Number(row && row.wave_id || 0);
const waveNo = String(row && row.wave_no || '').trim();
if (!Number.isInteger(orderId) || orderId <= 0 || !Number.isInteger(waveId) || waveId <= 0) {
continue;
}
if (!waveInfoById.has(waveId)) {
waveInfoById.set(waveId, {
wave_id: waveId,
wave_no: waveNo || '未知波次',
});
}
if (this.isExceptionRemovableOrder(row)) {
exceptionOrderIds.push(orderId);
}
}
const targetWaves = waveIds
.map(waveId => waveInfoById.get(waveId))
.filter(Boolean);
const normalizedExceptionOrderIds = [ ...new Set(exceptionOrderIds) ];
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: targetWaves.length,
total_order_count: normalizedExceptionOrderIds.length,
processed_order_count: normalizedExceptionOrderIds.length,
progress_percent: targetWaves.length === 0 ? 100 : 80,
});
if (normalizedExceptionOrderIds.length === 0) {
const durationMs = Date.now() - startTime;
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: targetWaves.length,
total_order_count: 0,
processed_order_count: 0,
removed_order_count: 0,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
removed_order_ids: [],
removed_order_count: 0,
affected_wave_ids: [],
updated_wave_ids: [],
emptied_wave_ids: [],
total_order_count: 0,
processed_order_count: 0,
duration_ms: durationMs,
message: '未找到可移除的异常订单',
},
});
return;
}
const removeResult = await this.batchRemoveOrders({
ids: normalizedExceptionOrderIds,
});
const resultPayload = this.isPlainObject(removeResult) ? removeResult : {};
const removedOrderIds = Array.isArray(resultPayload.removed_order_ids) ? resultPayload.removed_order_ids : [];
const affectedWaveIds = Array.isArray(resultPayload.affected_wave_ids) ? resultPayload.affected_wave_ids : [];
const updatedWaveIds = Array.isArray(resultPayload.updated_wave_ids) ? resultPayload.updated_wave_ids : [];
const emptiedWaveIds = Array.isArray(resultPayload.emptied_wave_ids) ? resultPayload.emptied_wave_ids : [];
const removedOrderCount = Number(resultPayload.removed_order_count || removedOrderIds.length || 0);
const durationMs = Date.now() - startTime;
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: targetWaves.length,
total_order_count: normalizedExceptionOrderIds.length,
processed_order_count: normalizedExceptionOrderIds.length,
removed_order_count: removedOrderCount,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
removed_order_ids: removedOrderIds,
removed_order_count: removedOrderCount,
affected_wave_ids: affectedWaveIds,
updated_wave_ids: updatedWaveIds,
emptied_wave_ids: emptiedWaveIds,
total_order_count: normalizedExceptionOrderIds.length,
processed_order_count: normalizedExceptionOrderIds.length,
duration_ms: durationMs,
message: `已移除 ${removedOrderCount} 条异常订单`,
},
});
} catch (error) {
await this.setBatchRemoveExceptionOrdersTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
progress_percent: 0,
end_time: Date.now(),
duration_ms: Date.now() - startTime,
error: error && error.message ? error.message : `${error}`,
error_code: 'WAVE_BATCH_REMOVE_EXCEPTION_ORDERS_FAILED',
});
}
}
/**
* 归一化批量取消波次ID参数。
*
* @param {Object} data 请求参数。
* @return {Array<number>} 归一化后的波次ID数组。
*/
normalizeBatchCancelWaveIds(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
const rawWaveIds = normalizedData.wave_ids !== undefined
? normalizedData.wave_ids
: normalizedData.waveIds !== undefined
? normalizedData.waveIds
: normalizedData.ids !== undefined
? normalizedData.ids
: normalizedData.wave_id !== undefined
? normalizedData.wave_id
: normalizedData.waveId;
return this.normalizeIdsInput(rawWaveIds);
}
/**
* 获取批量取消任务缓存键。
*
* @param {string} taskId 任务ID。
* @return {string} 缓存键。
*/
getBatchCancelTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${BATCH_CANCEL_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入批量取消任务进度缓存。
*
* @param {string} taskId 任务ID。
* @param {string} status 任务状态(submitted|running|success|failed)。
* @param {Object} data 进度或结果数据。
* @return {Promise<void>} 无返回值。
*/
async setBatchCancelTaskProgress(taskId = '', status = 'submitted', data = {}) {
const cacheKey = this.getBatchCancelTaskCacheKey(taskId);
if (!cacheKey) {
return;
}
const safeData = this.isPlainObject(data) ? data : {};
const mergedPayload = {
...(await this.getBatchCancelTaskProgress(taskId) || {}),
...safeData,
task_id: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, mergedPayload, BATCH_CANCEL_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[wave.batchCancel] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取批量取消任务进度缓存。
*
* @param {string} taskId 任务ID。
* @return {Promise<Object|null>} 缓存对象。
*/
async getBatchCancelTaskProgress(taskId = '') {
const cacheKey = this.getBatchCancelTaskCacheKey(taskId);
if (!cacheKey) {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
this.ctx.logger.warn('[wave.batchCancel] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
/**
* 执行批量解除波次后台任务。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
* @param {number|string} [params.warehouseId] 仓库ID(兜底)。
* @param {Array<number|string>|number|string} [params.waveIds] 波次ID集合(兜底)。
* @return {Promise<void>} 无返回值。
*/
async runBatchCancelTask(params = {}) {
const normalizedTaskId = String(params && params.taskId || '').trim();
if (!normalizedTaskId) {
throw new Error('taskId 不能为空');
}
const cachedTask = await this.getBatchCancelTaskProgress(normalizedTaskId);
const warehouseId = Number(
cachedTask && cachedTask.warehouse_id !== undefined
? cachedTask.warehouse_id
: params && params.warehouseId
);
const waveIds = this.normalizeIdsInput(
cachedTask && cachedTask.wave_ids !== undefined
? cachedTask.wave_ids
: params && params.waveIds
);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
await this.setBatchCancelTaskProgress(normalizedTaskId, 'failed', {
end_time: Date.now(),
error: 'warehouse_id 参数不合法',
error_code: 'INVALID_WAREHOUSE_ID',
});
return;
}
if (waveIds.length === 0) {
await this.setBatchCancelTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
end_time: Date.now(),
error: 'wave_ids 参数不能为空或格式错误',
error_code: 'INVALID_WAVE_IDS',
});
return;
}
const startTime = Date.now();
await this.setBatchCancelTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
wave_ids: waveIds.join(','),
wave_id_list: waveIds,
total_wave_count: waveIds.length,
processed_wave_count: 0,
progress_percent: 0,
start_time: startTime,
end_time: null,
result: null,
error: '',
error_code: '',
failed_wave_id: 0,
failed_wave_no: '',
});
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const querySql = `
SELECT wave_id, wave_no
FROM wms_wave_batch
WHERE warehouse_id = :warehouseId
AND wave_id IN (:ids)
`;
const queryRows = await this.ctx.model.query(querySql, {
replacements: {
warehouseId,
ids: waveIds,
},
type: this.ctx.model.QueryTypes.SELECT,
});
const targetWaves = (Array.isArray(queryRows) ? queryRows : [])
.map(row => ({
wave_id: Number(row && row.wave_id || 0),
wave_no: String(row && row.wave_no || '').trim(),
}))
.filter(item => Number.isInteger(item.wave_id) && item.wave_id > 0);
if (targetWaves.length === 0) {
await this.setBatchCancelTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: 0,
processed_wave_count: 0,
progress_percent: 100,
end_time: Date.now(),
duration_ms: Date.now() - startTime,
result: {
ids: waveIds,
affected_wave_ids: [],
affected_order_count: 0,
canceled_wave_count: 0,
duration_ms: Date.now() - startTime,
},
});
return;
}
let processedWaveCount = 0;
let affectedOrderCount = 0;
let canceledWaveCount = 0;
const affectedWaveIds = [];
for (const wave of targetWaves) {
const waveId = Number(wave.wave_id || 0);
const waveNo = String(wave.wave_no || '').trim() || '未知波次';
const transaction = await this.ctx.model.transaction();
try {
const affectedOrderRows = await orderModel.findAll({
attributes: [ 'id', 'wave_id', 'wave_no' ],
where: {
wave_id: waveId,
},
raw: true,
transaction,
});
const cancelOrderLogItems = (Array.isArray(affectedOrderRows) ? affectedOrderRows : [])
.map(row => {
const orderId = Number(row && row.id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
return null;
}
return {
orderId,
operationCode: 'ORDER_WAVE_CANCEL',
message: `波次 ${waveNo} 被删除,订单移出波次`,
};
})
.filter(Boolean);
const orderUpdateResult = await orderModel.update({
wave_id: 0,
wave_no: '',
}, {
where: {
wave_id: waveId,
},
transaction,
});
const currentAffectedOrderCount = Number(
Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0
);
const cancelSql = `
UPDATE wms_wave_batch
SET wave_status = -1,
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id = :waveId
`;
const cancelResult = await this.ctx.model.query(cancelSql, {
replacements: {
warehouseId,
waveId,
},
transaction,
});
const cancelMeta = Array.isArray(cancelResult) ? cancelResult[1] : null;
const currentCanceledWaveCount = Number(
cancelMeta && (cancelMeta.affectedRows || cancelMeta.affectedCount || cancelMeta.rowCount)
|| 0
);
await transaction.commit();
await this.batchCreateOrderOperationLogs(cancelOrderLogItems, {
warehouseId,
scene: 'batchCancel',
});
processedWaveCount += 1;
affectedOrderCount += Number.isInteger(currentAffectedOrderCount) && currentAffectedOrderCount > 0
? currentAffectedOrderCount
: 0;
canceledWaveCount += Number.isInteger(currentCanceledWaveCount) && currentCanceledWaveCount > 0
? currentCanceledWaveCount
: 0;
if (currentCanceledWaveCount > 0) {
affectedWaveIds.push(waveId);
}
const progressPercent = Math.min(100, Math.round((processedWaveCount / targetWaves.length) * 100));
await this.setBatchCancelTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: processedWaveCount,
progress_percent: progressPercent,
});
} catch (error) {
await transaction.rollback();
await this.setBatchCancelTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: processedWaveCount,
progress_percent: Math.min(100, Math.round((processedWaveCount / targetWaves.length) * 100)),
end_time: Date.now(),
duration_ms: Date.now() - startTime,
failed_wave_id: waveId,
failed_wave_no: waveNo,
error: error && error.message ? error.message : `${error}`,
error_code: 'WAVE_BATCH_CANCEL_FAILED',
result: {
ids: waveIds,
affected_wave_ids: affectedWaveIds,
affected_order_count: affectedOrderCount,
canceled_wave_count: canceledWaveCount,
duration_ms: Date.now() - startTime,
},
});
return;
}
}
const durationMs = Date.now() - startTime;
await this.setBatchCancelTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: targetWaves.length,
processed_wave_count: processedWaveCount,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
ids: waveIds,
affected_wave_ids: affectedWaveIds,
affected_order_count: affectedOrderCount,
canceled_wave_count: canceledWaveCount,
duration_ms: durationMs,
},
});
}
/**
* 生成可追踪的批次分配快递号任务ID。
*
* 格式:wave_allocate_express_{warehouseId}_{timestamp}_{rand}。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 任务ID。
*/
generateBatchAllocateExpressTaskId(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: 0;
const timestamp = Math.floor(Date.now() / 1000);
const randomPart = Math.random().toString(36).slice(2, 6);
return `wave_allocate_express_${safeWarehouseId}_${timestamp}_${randomPart}`;
}
/**
* 归一化批次分配快递号任务ID。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {string} 归一化后的任务ID。
*/
normalizeBatchAllocateExpressTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 归一化批次分配快递号波次ID参数。
*
* @param {Object} data 请求参数。
* @return {Array<number>} 归一化后的波次ID数组。
*/
normalizeBatchAllocateExpressWaveIds(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
const rawWaveIds = normalizedData.wave_ids !== undefined
? normalizedData.wave_ids
: normalizedData.waveIds !== undefined
? normalizedData.waveIds
: normalizedData.ids !== undefined
? normalizedData.ids
: normalizedData.wave_id !== undefined
? normalizedData.wave_id
: normalizedData.waveId;
return this.normalizeIdsInput(rawWaveIds);
}
/**
* 获取批次分配快递号任务缓存键。
*
* @param {string} taskId 任务ID。
* @return {string} 缓存键。
*/
getBatchAllocateExpressTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${BATCH_ALLOCATE_EXPRESS_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入批次分配快递号任务进度缓存。
*
* @param {string} taskId 任务ID。
* @param {string} status 任务状态(submitted|running|success|failed)。
* @param {Object} data 进度或结果数据。
* @return {Promise<void>} 无返回值。
*/
async setBatchAllocateExpressTaskProgress(taskId = '', status = 'submitted', data = {}) {
const cacheKey = this.getBatchAllocateExpressTaskCacheKey(taskId);
if (!cacheKey) {
return;
}
const safeData = this.isPlainObject(data) ? data : {};
const mergedPayload = {
...(await this.getBatchAllocateExpressTaskProgress(taskId) || {}),
...safeData,
task_id: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
update_time: Date.now(),
};
const traceId = this.buildBatchAllocateExpressTraceId(safeData, taskId);
try {
this.ctx.logger.info('[wave.batchAllocateExpress] 缓存回写前', {
traceId,
taskId: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
warehouseId: Number(mergedPayload.warehouse_id || 0),
waveIds: mergedPayload.wave_id_list || mergedPayload.wave_ids || '',
totalOrderCount: Number(mergedPayload.total_order_count || 0),
processedOrderCount: Number(mergedPayload.processed_order_count || 0),
});
await this.app.setCacheAsync(cacheKey, mergedPayload, BATCH_ALLOCATE_EXPRESS_TASK_CACHE_TTL_SECONDS);
this.ctx.logger.info('[wave.batchAllocateExpress] 缓存回写后', {
traceId,
taskId: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
});
} catch (error) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取批次分配快递号任务进度缓存。
*
* @param {string} taskId 任务ID。
* @return {Promise<Object|null>} 缓存对象。
*/
async getBatchAllocateExpressTaskProgress(taskId = '') {
const cacheKey = this.getBatchAllocateExpressTaskCacheKey(taskId);
if (!cacheKey) {
return null;
}
try {
this.ctx.logger.info('[wave.batchAllocateExpress] 缓存读取前', {
traceId: this.buildBatchAllocateExpressTraceId({}, taskId),
taskId: String(taskId || '').trim(),
});
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
this.ctx.logger.info('[wave.batchAllocateExpress] 缓存读取后-未命中', {
traceId: this.buildBatchAllocateExpressTraceId({}, taskId),
taskId: String(taskId || '').trim(),
});
return null;
}
this.ctx.logger.info('[wave.batchAllocateExpress] 缓存读取后-命中', {
traceId: this.buildBatchAllocateExpressTraceId(cached, taskId),
taskId: String(taskId || '').trim(),
state: String(cached.state || '').trim() || 'submitted',
});
return cached;
} catch (error) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
/**
* 生成可追踪的批次分配储位任务ID。
*
* 格式:wave_allocate_storage_{warehouseId}_{timestamp}_{rand}。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 任务ID。
*/
generateBatchAllocateStorageTaskId(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: 0;
const timestamp = Math.floor(Date.now() / 1000);
const randomPart = Math.random().toString(36).slice(2, 6);
return `wave_allocate_storage_${safeWarehouseId}_${timestamp}_${randomPart}`;
}
/**
* 归一化批次分配储位任务ID。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {string} 归一化后的任务ID。
*/
normalizeBatchAllocateStorageTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 归一化批次分配储位波次ID参数。
*
* @param {Object} data 请求参数。
* @return {Array<number>} 归一化后的波次ID数组。
*/
normalizeBatchAllocateStorageWaveIds(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
const rawWaveIds = normalizedData.wave_ids !== undefined
? normalizedData.wave_ids
: normalizedData.waveIds !== undefined
? normalizedData.waveIds
: normalizedData.ids !== undefined
? normalizedData.ids
: normalizedData.wave_id !== undefined
? normalizedData.wave_id
: normalizedData.waveId;
return this.normalizeIdsInput(rawWaveIds);
}
/**
* 归一化批次分配储位任务数量。
*
* @param {*} value 原始数量值。
* @param {number} [defaultValue=0] 默认值。
* @return {number} 非负整数数量。
*/
normalizeBatchAllocateStorageTaskCount(value, defaultValue = 0) {
const normalizedValue = Number(value);
if (!Number.isFinite(normalizedValue)) {
return Math.max(0, Number(defaultValue || 0));
}
const safeValue = Math.floor(normalizedValue);
if (!Number.isInteger(safeValue) || safeValue < 0) {
return 0;
}
return safeValue;
}
/**
* 构建批次分配储位 running 状态的进度写入数据。
*
* running 阶段的 progress_percent 强制上限 99,避免在任务真正完成前提前显示 100%。
*
* @param {Object} payload 进度回调载荷。
* @param {Object} cachedProgress 当前缓存中的任务进度。
* @return {{ total_order_count: number, processed_order_count: number, progress_percent: number }} 进度写入数据。
*/
buildBatchAllocateStorageRunningProgressPayload(payload = {}, cachedProgress = {}) {
const normalizedPayload = this.isPlainObject(payload) ? payload : {};
const normalizedCache = this.isPlainObject(cachedProgress) ? cachedProgress : {};
const totalOrderCount = this.normalizeBatchAllocateStorageTaskCount(
normalizedPayload.total_count,
normalizedCache.total_order_count
);
const rawProcessedOrderCount = this.normalizeBatchAllocateStorageTaskCount(
normalizedPayload.processed_count,
normalizedCache.processed_order_count
);
const processedOrderCount = totalOrderCount > 0
? Math.min(rawProcessedOrderCount, totalOrderCount)
: rawProcessedOrderCount;
const fallbackProgressPercent = this.normalizeBatchAllocateStorageTaskCount(
normalizedPayload.progress_percent,
normalizedCache.progress_percent
);
const calculatedProgressPercent = totalOrderCount > 0
? Math.round((processedOrderCount / totalOrderCount) * 100)
: fallbackProgressPercent;
return {
total_order_count: totalOrderCount,
processed_order_count: processedOrderCount,
progress_percent: Math.max(0, Math.min(99, calculatedProgressPercent)),
};
}
/**
* 归一化批次分配储位成功态订单ID列表。
*
* @param {*} value 原始订单ID集合。
* @return {Array<number>} 去重后的订单ID列表。
*/
normalizeBatchAllocateStorageOrderIds(value) {
return [ ...new Set(this.normalizeIdsInput(value)) ];
}
/**
* 获取批次分配储位任务缓存键。
*
* @param {string} taskId 任务ID。
* @return {string} 缓存键。
*/
getBatchAllocateStorageTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${BATCH_ALLOCATE_STORAGE_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 获取批次分配储位仓库并发锁键。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 锁键。
*/
getBatchAllocateStorageWarehouseLockKey(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return '';
}
return `wave_allocate_storage_lock_${normalizedWarehouseId}`;
}
/**
* 尝试获取批次分配储位仓库维度并发锁。
*
* 该锁仅在当前 Node.js 进程内生效,用于避免同仓库并发触发多个大事务。
*
* @param {number|string} warehouseId 仓库ID。
* @param {string} [taskId=''] 当前任务ID。
* @return {{ acquired: boolean, ownerTaskId: string }} 获取结果。
*/
tryAcquireBatchAllocateStorageWarehouseLock(warehouseId = 0, taskId = '') {
const lockKey = this.getBatchAllocateStorageWarehouseLockKey(warehouseId);
if (!lockKey) {
return {
acquired: false,
ownerTaskId: '',
};
}
if (BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP.has(lockKey)) {
return {
acquired: false,
ownerTaskId: String(BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP.get(lockKey) || '').trim(),
};
}
BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP.set(lockKey, String(taskId || '').trim());
return {
acquired: true,
ownerTaskId: String(taskId || '').trim(),
};
}
/**
* 释放批次分配储位仓库维度并发锁。
*
* @param {number|string} warehouseId 仓库ID。
* @param {string} [taskId=''] 当前任务ID。
* @return {void}
*/
releaseBatchAllocateStorageWarehouseLock(warehouseId = 0, taskId = '') {
const lockKey = this.getBatchAllocateStorageWarehouseLockKey(warehouseId);
if (!lockKey) {
return;
}
const ownerTaskId = String(BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP.get(lockKey) || '').trim();
const normalizedTaskId = String(taskId || '').trim();
if (!ownerTaskId || ownerTaskId === normalizedTaskId) {
BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP.delete(lockKey);
}
}
/**
* 写入批次分配储位任务进度缓存。
*
* @param {string} taskId 任务ID。
* @param {string} status 任务状态(submitted|running|success|failed)。
* @param {Object} data 进度或结果数据。
* @return {Promise<void>} 无返回值。
*/
async setBatchAllocateStorageTaskProgress(taskId = '', status = 'submitted', data = {}) {
const cacheKey = this.getBatchAllocateStorageTaskCacheKey(taskId);
if (!cacheKey) {
return;
}
const safeData = this.isPlainObject(data) ? data : {};
const mergedPayload = {
...(await this.getBatchAllocateStorageTaskProgress(taskId) || {}),
...safeData,
task_id: String(taskId || '').trim(),
state: String(status || '').trim() || 'submitted',
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, mergedPayload, BATCH_ALLOCATE_STORAGE_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[wave.batchAllocateStorage] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取批次分配储位任务进度缓存。
*
* @param {string} taskId 任务ID。
* @return {Promise<Object|null>} 缓存对象。
*/
async getBatchAllocateStorageTaskProgress(taskId = '') {
const cacheKey = this.getBatchAllocateStorageTaskCacheKey(taskId);
if (!cacheKey) {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
this.ctx.logger.warn('[wave.batchAllocateStorage] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
/**
* 判断是否为 business_key 列不存在错误。
*
* 兼容 MySQL/Sequelize 常见报错文案,例如:
* Unknown column 'business_key' in 'field list'
*
* @param {Error|Object} error 异常对象。
* @return {boolean} 是否为 business_key 缺列错误。
*/
isMissingBusinessKeyColumnError(error) {
const messageList = [
error && error.message,
error && error.parent && error.parent.message,
error && error.original && error.original.message,
error && error.sqlMessage,
]
.map(item => String(item || '').toLowerCase())
.filter(Boolean);
return messageList.some(message => {
const hasUnknownColumn = message.includes('unknown column') || message.includes('column does not exist');
const hasBusinessKey = message.includes('business_key');
return hasUnknownColumn && hasBusinessKey;
});
}
/**
* 执行批次分配快递号后台任务。
*
* 任务仅负责提交分配请求到快递分配流水线,实际分配过程由快递服务异步处理。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
* @param {number|string} [params.warehouseId] 仓库ID(兜底)。
* @param {Array<number|string>|number|string} [params.waveIds] 波次ID集合(兜底)。
* @return {Promise<void>} 无返回值。
*/
async runBatchAllocateExpressTask(params = {}) {
const normalizedTaskId = String(params && params.taskId || '').trim();
if (!normalizedTaskId) {
throw new Error('taskId 不能为空');
}
const cachedTask = await this.getBatchAllocateExpressTaskProgress(normalizedTaskId);
const traceId = this.buildBatchAllocateExpressTraceId(cachedTask || params, normalizedTaskId);
const warehouseId = Number(
cachedTask && cachedTask.warehouse_id !== undefined
? cachedTask.warehouse_id
: params && params.warehouseId
);
const waveIds = this.normalizeIdsInput(
cachedTask && cachedTask.wave_ids !== undefined
? cachedTask.wave_ids
: params && params.waveIds
);
this.ctx.logger.info('[wave.batchAllocateExpress] 后台任务入口', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
paramsSnapshot: {
warehouseId: params && params.warehouseId,
waveIds: params && params.waveIds,
},
});
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 后台任务参数校验失败-warehouse_id 非法', {
traceId,
taskId: normalizedTaskId,
warehouseId,
});
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'failed', {
end_time: Date.now(),
error: 'warehouse_id 参数不合法',
error_code: 'INVALID_WAREHOUSE_ID',
trace_id: traceId,
});
return;
}
if (waveIds.length === 0) {
this.ctx.logger.warn('[wave.batchAllocateExpress] 后台任务参数校验失败-wave_ids 为空', {
traceId,
taskId: normalizedTaskId,
warehouseId,
});
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
end_time: Date.now(),
error: 'wave_ids 参数不能为空或格式错误',
error_code: 'INVALID_WAVE_IDS',
trace_id: traceId,
});
return;
}
const startTime = Date.now();
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
wave_ids: waveIds.join(','),
wave_id_list: waveIds,
total_wave_count: waveIds.length,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
progress_percent: 0,
start_time: startTime,
end_time: null,
result: null,
error: '',
error_code: '',
trace_id: traceId,
});
try {
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const baseOrderWhere = {
warehouse_id: warehouseId,
wave_id: {
[Op.in]: waveIds,
},
step: {
[Op.in]: [ 1, 2, 3 ],
},
};
let orderRows = [];
let useBusinessKeyColumn = true;
try {
orderRows = await orderModel.findAll({
attributes: [ 'id', 'business_key' ],
where: baseOrderWhere,
raw: true,
});
} catch (error) {
if (!this.isMissingBusinessKeyColumnError(error)) {
throw error;
}
useBusinessKeyColumn = false;
this.ctx.logger.warn('[wave.batchAllocateExpress] 订单分表缺少 business_key 列,降级为仅查询 id', {
traceId,
taskId: normalizedTaskId,
warehouseId,
});
orderRows = await orderModel.findAll({
attributes: [ 'id' ],
where: baseOrderWhere,
raw: true,
});
}
this.ctx.logger.info('[wave.batchAllocateExpress] 订单筛选完成', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
useBusinessKeyColumn,
matchedOrderCount: Array.isArray(orderRows) ? orderRows.length : 0,
});
const normalizedOrders = (Array.isArray(orderRows) ? orderRows : [])
.map(row => {
const orderId = Number(row && row.id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
return null;
}
const businessKey = Number(useBusinessKeyColumn ? row && row.business_key : 1);
return {
order_id: orderId,
business_key: Number.isInteger(businessKey) && businessKey > 0 ? businessKey : 1,
};
})
.filter(Boolean);
if (normalizedOrders.length === 0) {
this.ctx.logger.info('[wave.batchAllocateExpress] 未筛选到可分配快递号订单', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
});
const durationMs = Date.now() - startTime;
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
allocated_order_count: 0,
duration_ms: durationMs,
message: '未找到可分配快递号的订单',
},
trace_id: traceId,
});
return;
}
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
total_order_count: normalizedOrders.length,
trace_id: traceId,
});
this.ctx.logger.info('[wave.batchAllocateExpress] 即将调用快递号分配流水线', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
totalOrderCount: normalizedOrders.length,
sampleOrderIds: normalizedOrders.slice(0, 20).map(item => Number(item && item.order_id || 0)).filter(Boolean),
});
const pipelineResult = await this.service.systems.express.createWaybillCodePipeline(normalizedOrders);
const durationMs = Date.now() - startTime;
this.ctx.logger.info('[wave.batchAllocateExpress] 快递号分配流水线执行完成', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
totalOrderCount: normalizedOrders.length,
durationMs,
pipelineResult,
});
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
total_order_count: normalizedOrders.length,
processed_order_count: normalizedOrders.length,
success_order_count: normalizedOrders.length,
failed_order_count: 0,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
allocated_order_count: normalizedOrders.length,
duration_ms: durationMs,
message: String(pipelineResult && pipelineResult.message || '分配快递任务已提交').trim(),
},
trace_id: traceId,
});
} catch (error) {
this.ctx.logger.error('[wave.batchAllocateExpress] 后台任务执行失败', {
traceId,
taskId: normalizedTaskId,
warehouseId,
waveIds,
error: error && error.message ? error.message : `${error}`,
stack: error && error.stack ? error.stack : '',
});
await this.setBatchAllocateExpressTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
progress_percent: 0,
end_time: Date.now(),
duration_ms: Date.now() - startTime,
error: error && error.message ? error.message : `${error}`,
error_code: 'WAVE_BATCH_ALLOCATE_EXPRESS_FAILED',
trace_id: traceId,
});
}
}
/**
* 执行批次分配储位后台任务。
*
* 任务仅负责按波次拉取订单并提交储位分配流水线,实际分配过程复用储位分配服务。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
* @param {number|string} [params.warehouseId] 仓库ID(兜底)。
* @param {Array<number|string>|number|string} [params.waveIds] 波次ID集合(兜底)。
* @return {Promise<void>} 无返回值。
*/
async runBatchAllocateStorageTask(params = {}) {
const normalizedTaskId = String(params && params.taskId || '').trim();
if (!normalizedTaskId) {
throw new Error('taskId 不能为空');
}
const cachedTask = await this.getBatchAllocateStorageTaskProgress(normalizedTaskId);
const warehouseId = Number(
cachedTask && cachedTask.warehouse_id !== undefined
? cachedTask.warehouse_id
: params && params.warehouseId
);
const waveIds = this.normalizeIdsInput(
cachedTask && cachedTask.wave_ids !== undefined
? cachedTask.wave_ids
: params && params.waveIds
);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'failed', {
end_time: Date.now(),
error: 'warehouse_id 参数不合法',
error_code: 'INVALID_WAREHOUSE_ID',
});
return;
}
if (waveIds.length === 0) {
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
end_time: Date.now(),
error: 'wave_ids 参数不能为空或格式错误',
error_code: 'INVALID_WAVE_IDS',
});
return;
}
const startTime = Date.now();
const lockResult = this.tryAcquireBatchAllocateStorageWarehouseLock(warehouseId, normalizedTaskId);
if (!lockResult.acquired) {
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
progress_percent: 0,
end_time: Date.now(),
duration_ms: Date.now() - startTime,
error: lockResult.ownerTaskId
? `同仓库存在执行中的批量储位分配任务,请稍后重试(running_task_id=${lockResult.ownerTaskId})`
: '同仓库存在执行中的批量储位分配任务,请稍后重试',
error_code: 'WAVE_BATCH_ALLOCATE_STORAGE_WAREHOUSE_CONFLICT',
});
return;
}
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
wave_ids: waveIds.join(','),
wave_id_list: waveIds,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
total_wave_count: waveIds.length,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
progress_percent: 0,
start_time: startTime,
end_time: null,
result: null,
error: '',
error_code: '',
});
try {
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderRows = await orderModel.findAll({
attributes: [ 'id' ],
where: {
warehouse_id: warehouseId,
wave_id: {
[Op.in]: waveIds,
},
step: {
[Op.in]: [ 1, 2, 3 ],
},
},
raw: true,
});
const normalizedOrders = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
.map(row => Number(row && row.id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ]
.map(orderId => ({
order_id: orderId,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
}));
const normalizedOrderIds = normalizedOrders.map(item => Number(item.order_id || 0)).filter(Boolean);
if (normalizedOrderIds.length === 0) {
const durationMs = Date.now() - startTime;
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
total_order_count: 0,
processed_order_count: 0,
success_order_count: 0,
failed_order_count: 0,
affected_order_ids: [],
affected_order_count: 0,
allocated_order_ids: [],
allocated_order_count: 0,
shortage_order_ids: [],
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
affected_order_ids: [],
affected_order_count: 0,
allocated_order_ids: [],
allocated_order_count: 0,
shortage_order_ids: [],
duration_ms: durationMs,
message: '未找到可分配储位的订单',
},
});
return;
}
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
total_order_count: normalizedOrderIds.length,
});
const progressCallback = async callbackPayload => {
const latestProgress = await this.getBatchAllocateStorageTaskProgress(normalizedTaskId);
const runningProgressPayload = this.buildBatchAllocateStorageRunningProgressPayload(
callbackPayload,
latestProgress || {
total_order_count: normalizedOrderIds.length,
processed_order_count: 0,
progress_percent: 0,
}
);
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
...runningProgressPayload,
});
};
const pipelineResult = await this.service.systems.orderStorageAllocation.allocateStorage({
ids: normalizedOrderIds,
orders: normalizedOrders,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
progress_callback: progressCallback,
});
if (!this.isPlainObject(pipelineResult) || Number(pipelineResult.code) !== 200) {
throw new Error(String(pipelineResult && pipelineResult.message || '储位分配任务提交失败').trim());
}
const resultData = this.isPlainObject(pipelineResult.data) ? pipelineResult.data : {};
const pendingOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.pending_order_ids);
const affectedOrderIds = pendingOrderIds.length > 0
? pendingOrderIds
: this.normalizeBatchAllocateStorageOrderIds(normalizedOrderIds);
const allocatedOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.allocated_order_ids);
const shortageOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.shortage_order_ids);
const affectedOrderCount = affectedOrderIds.length;
const successOrderCount = allocatedOrderIds.length;
const failedOrderCount = shortageOrderIds.length > 0
? shortageOrderIds.length
: Math.max(0, affectedOrderCount - successOrderCount);
const durationMs = Date.now() - startTime;
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'success', {
warehouse_id: warehouseId,
total_wave_count: waveIds.length,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
total_order_count: affectedOrderCount,
processed_order_count: affectedOrderCount,
success_order_count: successOrderCount,
failed_order_count: failedOrderCount,
affected_order_ids: affectedOrderIds,
affected_order_count: affectedOrderCount,
allocated_order_ids: allocatedOrderIds,
allocated_order_count: successOrderCount,
shortage_order_ids: shortageOrderIds,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
result: {
wave_ids: waveIds,
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
affected_order_ids: affectedOrderIds,
affected_order_count: affectedOrderCount,
allocated_order_ids: allocatedOrderIds,
allocated_order_count: successOrderCount,
shortage_order_ids: shortageOrderIds,
duration_ms: durationMs,
message: String(pipelineResult && pipelineResult.message || '分配储位任务已提交').trim(),
},
});
} catch (error) {
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'failed', {
warehouse_id: warehouseId,
progress_percent: 0,
end_time: Date.now(),
duration_ms: Date.now() - startTime,
error: error && error.message ? error.message : `${error}`,
error_code: 'WAVE_BATCH_ALLOCATE_STORAGE_FAILED',
});
} finally {
this.releaseBatchAllocateStorageWarehouseLock(warehouseId, normalizedTaskId);
}
}
/**
* 批量将波次状态改为“自动加团中”。
*
* 仅处理当前登录仓库下命中的波次状态,不修改订单表 wave_id。
*
* @param {Object} data 请求参数。
* @param {Array<number|string>|number|string} data.ids 波次ID集合。
* @return {Promise<Object>} 批量更新结果。
*/
async batchAutoGrouping(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const warehouseId = contextWarehouseId;
const normalizedIds = this.normalizeIdsInput(data && data.ids);
if (normalizedIds.length === 0) {
throw new Error('ids 参数不能为空或格式错误');
}
const maxWaveQuantity = await this.getDefaultWaveQuantity(warehouseId);
const transaction = await this.ctx.model.transaction();
try {
const querySql = `
SELECT wave_id, wave_status, total_orders
FROM wms_wave_batch
WHERE warehouse_id = :warehouseId
AND wave_id IN (:ids)
`;
const queryRows = await this.ctx.model.query(querySql, {
replacements: {
warehouseId,
ids: normalizedIds,
},
type: this.ctx.model.QueryTypes.SELECT,
transaction,
});
const affectedRows = Array.isArray(queryRows) ? queryRows : [];
const affectedWaveIds = [ ...new Set(affectedRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
const skippedDetails = [];
const skippedWaveIds = [];
const updatableWaveIds = [];
for (const row of affectedRows) {
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
const waveStatus = Number(row && row.wave_status || 0);
const totalOrders = Number(row && row.total_orders || 0);
if (waveStatus >= 2) {
skippedWaveIds.push(waveId);
skippedDetails.push({
wave_id: waveId,
reason: 'printed_or_after_printed',
});
continue;
}
if (totalOrders >= maxWaveQuantity) {
skippedWaveIds.push(waveId);
skippedDetails.push({
wave_id: waveId,
reason: 'reach_max_wave_quantity',
});
continue;
}
updatableWaveIds.push(waveId);
}
if (affectedWaveIds.length === 0) {
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: [],
skipped_wave_ids: [],
skipped_wave_count: 0,
skipped_details: [],
updated_wave_count: 0,
});
}
if (updatableWaveIds.length === 0) {
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: affectedWaveIds,
skipped_wave_ids: skippedWaveIds,
skipped_wave_count: skippedWaveIds.length,
skipped_details: skippedDetails,
updated_wave_count: 0,
});
}
const updateSql = `
UPDATE wms_wave_batch
SET wave_status = 0,
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
`;
const updateResult = await this.ctx.model.query(updateSql, {
replacements: {
warehouseId,
waveIds: updatableWaveIds,
},
transaction,
});
const updateMeta = Array.isArray(updateResult) ? updateResult[1] : null;
const updatedWaveCount = Number(
updateMeta && (updateMeta.affectedRows || updateMeta.affectedCount || updateMeta.rowCount)
|| updatableWaveIds.length
);
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: affectedWaveIds,
skipped_wave_ids: skippedWaveIds,
skipped_wave_count: skippedWaveIds.length,
skipped_details: skippedDetails,
updated_wave_count: Number.isInteger(updatedWaveCount) && updatedWaveCount > 0 ? updatedWaveCount : 0,
});
} catch (error) {
await transaction.rollback();
throw error;
}
}
/**
* 批量结束“自动加团中”状态。
*
* 仅处理当前登录仓库下命中的波次,且仅将 wave_status=0 的波次更新为 1(已就绪)。
*
* @param {Object} data 请求参数。
* @param {Array<number|string>|number|string} data.ids 波次ID集合。
* @return {Promise<Object>} 批量结束结果。
*/
async batchFinishAutoGrouping(data = {}) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const warehouseId = contextWarehouseId;
const normalizedIds = this.normalizeIdsInput(data && data.ids);
if (normalizedIds.length === 0) {
throw new Error('ids 参数不能为空或格式错误');
}
const transaction = await this.ctx.model.transaction();
try {
const querySql = `
SELECT wave_id, wave_status
FROM wms_wave_batch
WHERE warehouse_id = :warehouseId
AND wave_id IN (:ids)
`;
const queryRows = await this.ctx.model.query(querySql, {
replacements: {
warehouseId,
ids: normalizedIds,
},
type: this.ctx.model.QueryTypes.SELECT,
transaction,
});
const affectedRows = Array.isArray(queryRows) ? queryRows : [];
const affectedWaveIds = [ ...new Set(affectedRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
if (affectedWaveIds.length === 0) {
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: [],
updated_wave_ids: [],
updated_wave_count: 0,
});
}
const updatedWaveIds = [ ...new Set(affectedRows
.filter(row => Number(row && row.wave_status || 0) === 0)
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
if (updatedWaveIds.length === 0) {
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: affectedWaveIds,
updated_wave_ids: [],
updated_wave_count: 0,
});
}
const updateSql = `
UPDATE wms_wave_batch
SET wave_status = 1,
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
AND wave_status = 0
`;
const updateResult = await this.ctx.model.query(updateSql, {
replacements: {
warehouseId,
waveIds: updatedWaveIds,
},
transaction,
});
const updateMeta = Array.isArray(updateResult) ? updateResult[1] : null;
const updatedWaveCount = Number(
updateMeta && (updateMeta.affectedRows || updateMeta.affectedCount || updateMeta.rowCount)
|| updatedWaveIds.length
);
await transaction.commit();
return this.success('ok', {
ids: normalizedIds,
affected_wave_ids: affectedWaveIds,
updated_wave_ids: updatedWaveIds,
updated_wave_count: Number.isInteger(updatedWaveCount) && updatedWaveCount > 0 ? updatedWaveCount : 0,
});
} catch (error) {
await transaction.rollback();
throw error;
}
}
/**
* 生成可追踪的抓取任务ID。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 抓取任务ID。
*/
generateFetchTaskId(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
? normalizedWarehouseId
: 0;
const waveIdSeed = this.generateWaveId();
return `wave_fetch_${safeWarehouseId}_${waveIdSeed}`;
}
/**
* 归一化抓取任务ID。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {string} 归一化后的任务ID。
*/
normalizeFetchTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 获取抓取任务进度缓存键。
*
* @param {string} taskId 任务ID。
* @return {string} 缓存键。
*/
getFetchTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${FETCH_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入抓取任务进度缓存。
*
* @param {string} taskId 任务ID。
* @param {Object} payload 进度数据。
* @return {Promise<void>} 无返回值。
*/
async setFetchTaskProgress(taskId = '', payload = {}) {
const cacheKey = this.getFetchTaskCacheKey(taskId);
if (!cacheKey) {
return;
}
const safePayload = this.isPlainObject(payload) ? payload : {};
const progressPayload = {
...safePayload,
task_id: String(taskId || '').trim(),
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, progressPayload, FETCH_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[wave.fetch] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取抓取任务进度缓存。
*
* @param {string} taskId 任务ID。
* @return {Promise<Object|null>} 任务进度缓存。
*/
async getFetchTaskProgress(taskId = '') {
const cacheKey = this.getFetchTaskCacheKey(taskId);
if (!cacheKey) {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
this.ctx.logger.warn('[wave.fetch] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
/**
* 查询抓取任务进度。
*
* @param {Object} data 请求参数。
* @param {string} data.task_id 任务ID(下划线写法)。
* @param {string} data.taskId 任务ID(驼峰写法)。
* @return {Promise<Object>} 任务进度响应。
*/
async fetchTaskProgress(data = {}) {
const taskId = this.normalizeFetchTaskId(data);
if (!taskId) {
return this.fail('task_id 参数不能为空', 400);
}
const cachedProgress = await this.getFetchTaskProgress(taskId);
if (!cachedProgress) {
return this.success('ok', {
task_id: taskId,
status: 'not_found',
});
}
return this.success('ok', {
task_id: taskId,
...cachedProgress,
status: String(cachedProgress.status || 'unknown').trim() || 'unknown',
});
}
/**
* 执行异步抓取任务。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.defaultQuantity 默认抓取数量。
* @param {Array<Object>} params.structures 结构化抓取请求。
* @param {string} [params.fetchMode='group'] 抓取模式:group|single。
* @param {number} [params.maxFetchQuantity=0] single 模式最大抓取订单数上限。
* @return {Promise<void>} 无返回值。
*/
async runFetchTask({
taskId = '',
warehouseId = 0,
defaultQuantity = DEFAULT_MAX_WAVE_QUANTITY,
structures = [],
fetchMode = 'group',
maxFetchQuantity = 0,
} = {}) {
const normalizedTaskId = String(taskId || '').trim();
const normalizedWarehouseId = Number(warehouseId || 0);
const structureList = Array.isArray(structures) ? structures : [];
const normalizedFetchMode = String(fetchMode || 'group').trim() === 'single' ? 'single' : 'group';
const normalizedMaxFetchQuantity = Number.isInteger(Number(maxFetchQuantity)) && Number(maxFetchQuantity) > 0
? Number(maxFetchQuantity)
: 0;
if (!normalizedTaskId) {
throw new Error('taskId 不能为空');
}
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('warehouseId 参数不合法');
}
if (structureList.length === 0) {
throw new Error('structures 不能为空');
}
if (normalizedFetchMode === 'single' && normalizedMaxFetchQuantity <= 0) {
throw new Error('single 模式要求 maxFetchQuantity 为正整数');
}
this.ctx.logger.info('[wave.fetch] 后台任务开始', {
taskId: normalizedTaskId,
warehouseId: normalizedWarehouseId,
structureCount: structureList.length,
defaultQuantity: Number(defaultQuantity || 0),
fetchMode: normalizedFetchMode,
maxFetchQuantity: normalizedMaxFetchQuantity,
autoFetchDisabledMarker: WAVE_MANUAL_FETCH_FLAG,
});
const startedAt = Date.now();
await this.setFetchTaskProgress(normalizedTaskId, {
status: 'running',
warehouse_id: normalizedWarehouseId,
structure_count: structureList.length,
finished_structure_count: 0,
progress_percent: 0,
default_quantity: Number(defaultQuantity || 0),
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
started_at: startedAt,
});
try {
const groupWavePrefix = await this.getGroupWavePrefix(normalizedWarehouseId);
const minGroupOrderFetchQuantity = await this.getMinGroupOrderFetchQuantity(normalizedWarehouseId);
const model = await this.getOrderModel('pendingOrder', normalizedWarehouseId);
const results = [];
let totalFetchedQuantity = 0;
let reachedLimit = false;
for (let i = 0; i < structureList.length; i++) {
if (normalizedFetchMode === 'single' && totalFetchedQuantity >= normalizedMaxFetchQuantity) {
reachedLimit = true;
break;
}
const structure = structureList[i];
const remainingFetchQuantity = normalizedFetchMode === 'single'
? normalizedMaxFetchQuantity - totalFetchedQuantity
: 0;
const result = await this.fetchSingleStructure(
model,
structure,
normalizedWarehouseId,
groupWavePrefix,
normalizedFetchMode === 'single' ? 1 : minGroupOrderFetchQuantity,
{
maxFetchQuantity: remainingFetchQuantity,
}
);
results.push(result);
totalFetchedQuantity += Number(result.fetched_quantity || 0);
if (normalizedFetchMode === 'single' && totalFetchedQuantity >= normalizedMaxFetchQuantity) {
reachedLimit = true;
}
const finishedStructureCount = results.length;
const progressPercent = Math.min(
100,
Math.round((finishedStructureCount / structureList.length) * 100)
);
await this.setFetchTaskProgress(normalizedTaskId, {
status: 'running',
warehouse_id: normalizedWarehouseId,
structure_count: structureList.length,
finished_structure_count: finishedStructureCount,
progress_percent: progressPercent,
total_fetched_quantity: totalFetchedQuantity,
default_quantity: Number(defaultQuantity || 0),
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
...(normalizedFetchMode === 'single' ? { limit_reached: reachedLimit } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
started_at: startedAt,
});
}
const totalRequestQuantity = results.reduce((sum, item) => sum + Number(item.request_quantity || 0), 0);
const durationMs = Date.now() - startedAt;
const finishedStructureCount = results.length;
const progressPercent = structureList.length > 0
? Math.min(100, Math.round((finishedStructureCount / structureList.length) * 100))
: 100;
await this.setFetchTaskProgress(normalizedTaskId, {
status: 'success',
warehouse_id: normalizedWarehouseId,
structure_count: structureList.length,
finished_structure_count: finishedStructureCount,
progress_percent: progressPercent,
total_request_quantity: totalRequestQuantity,
total_fetched_quantity: totalFetchedQuantity,
default_quantity: Number(defaultQuantity || 0),
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
...(normalizedFetchMode === 'single' ? { limit_reached: reachedLimit } : {}),
...(normalizedFetchMode === 'single' && reachedLimit ? { stop_reason: '达到最大抓取上限' } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
started_at: startedAt,
duration_ms: durationMs,
});
this.ctx.logger.info('[wave.fetch] 后台任务完成', {
taskId: normalizedTaskId,
warehouseId: normalizedWarehouseId,
structureCount: structureList.length,
defaultQuantity: Number(defaultQuantity || 0),
fetchMode: normalizedFetchMode,
maxFetchQuantity: normalizedMaxFetchQuantity,
reachedLimit,
autoFetchDisabledMarker: WAVE_MANUAL_FETCH_FLAG,
totalRequestQuantity,
totalFetchedQuantity,
durationMs,
});
} catch (error) {
await this.setFetchTaskProgress(normalizedTaskId, {
status: 'failed',
warehouse_id: normalizedWarehouseId,
structure_count: structureList.length,
default_quantity: Number(defaultQuantity || 0),
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
started_at: startedAt,
duration_ms: Date.now() - startedAt,
error: error && error.message ? error.message : `${error}`,
});
throw error;
}
}
/**
* 提交异步抓取任务。
*
* @param {Object} data 请求参数。
* @param {'group'|'single'} [fetchMode='group'] 抓取模式。
* @param {number} [maxFetchQuantity=0] single 模式最大抓取订单数。
* @return {Promise<Object>} 任务提交结果。
*/
async submitFetchTask(data = {}, fetchMode = 'group', maxFetchQuantity = 0) {
const warehouseId = this.getWarehouseId();
const defaultQuantity = await this.getDefaultWaveQuantity(warehouseId);
const structures = this.normalizeFetchStructureRequests(data, defaultQuantity);
const taskId = this.generateFetchTaskId(warehouseId);
const normalizedFetchMode = String(fetchMode || 'group').trim() === 'single' ? 'single' : 'group';
const normalizedMaxFetchQuantity = Number.isInteger(Number(maxFetchQuantity)) && Number(maxFetchQuantity) > 0
? Number(maxFetchQuantity)
: 0;
await this.setFetchTaskProgress(taskId, {
status: 'submitted',
warehouse_id: Number(warehouseId || 0),
structure_count: structures.length,
finished_structure_count: 0,
progress_percent: 0,
default_quantity: defaultQuantity,
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
submitted_at: Date.now(),
});
this.ctx.logger.info('[wave.fetch] 任务提交成功', {
taskId,
warehouseId: Number(warehouseId || 0),
structureCount: structures.length,
defaultQuantity,
fetchMode: normalizedFetchMode,
maxFetchQuantity: normalizedMaxFetchQuantity,
autoFetchDisabledMarker: WAVE_MANUAL_FETCH_FLAG,
});
setImmediate(() => {
this.runFetchTask({
taskId,
warehouseId: Number(warehouseId || 0),
defaultQuantity,
structures,
fetchMode: normalizedFetchMode,
maxFetchQuantity: normalizedMaxFetchQuantity,
}).catch(error => {
this.ctx.logger.error('[wave.fetch] 后台任务异常', {
taskId,
warehouseId: Number(warehouseId || 0),
structureCount: structures.length,
defaultQuantity,
fetchMode: normalizedFetchMode,
maxFetchQuantity: normalizedMaxFetchQuantity,
autoFetchDisabledMarker: WAVE_MANUAL_FETCH_FLAG,
error: error && error.message ? error.message : error,
stack: error && error.stack ? error.stack : '',
});
});
});
return this.success('ok', {
task_id: taskId,
warehouse_id: Number(warehouseId || 0),
structure_count: structures.length,
default_quantity: defaultQuantity,
fetch_mode: normalizedFetchMode,
...(normalizedFetchMode === 'single' ? { max_fetch_quantity: normalizedMaxFetchQuantity } : {}),
auto_fetch_disabled_marker: WAVE_MANUAL_FETCH_FLAG,
message: '任务已提交,后端异步处理中',
});
}
/**
* 团购抓取波次:按机器结构标识批量抓取订单。
*
* @param {Object} data 请求参数。
* @param {Array<Object>} data.structure_list 结构请求数组。
* @return {Promise<Object>} 任务提交结果。
*/
async groupFetch(data = {}) {
return this.submitFetchTask(data, 'group', 0);
}
/**
* 散单抓取波次:支持按订单数上限停止。
*
* @param {Object} data 请求参数。
* @param {Array<Object>} data.structure_list 结构请求数组。
* @param {number|string} data.max_fetch_quantity 最大抓取订单数(必填正整数)。
* @return {Promise<Object>} 任务提交结果。
*/
async singleFetch(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
const maxFetchQuantity = this.normalizeRequiredPositiveInteger(
normalizedData.max_fetch_quantity ?? normalizedData.maxFetchQuantity,
'max_fetch_quantity'
);
return this.submitFetchTask(normalizedData, 'single', maxFetchQuantity);
}
/**
* 兼容旧方法名 fetch,内部转调 groupFetch。
*
* @param {Object} data 请求参数。
* @return {Promise<Object>} 任务提交结果。
*/
async fetch(data = {}) {
return this.groupFetch(data);
}
}
module.exports = WaveService;