8286 lines
291 KiB
JavaScript
8286 lines
291 KiB
JavaScript
'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 WAVE_STRATEGY_QUICK_SCAN_TASK_CACHE_KEY_PREFIX = 'wave:quick-scan:task:';
|
||
const WAVE_STRATEGY_QUICK_SCAN_TASK_CACHE_TTL_SECONDS = 60 * 60 * 24;
|
||
const WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_CACHE_KEY_PREFIX = 'wave:quick-scan:lock:';
|
||
const WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_TTL_SECONDS = 60 * 60 * 2;
|
||
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();
|
||
const WAVE_STRATEGY_FALLBACK_WHERE_FIELD_MAP = Object.freeze({
|
||
id: 'id',
|
||
delivery_no: 'delivery_order_code',
|
||
deliveryNo: 'delivery_order_code',
|
||
tracking_no: 'express_numbers',
|
||
trackingNo: 'express_numbers',
|
||
items_count: 'items_count',
|
||
items_count_min: 'items_count',
|
||
items_count_max: 'items_count',
|
||
items_total: 'items_total',
|
||
items_total_min: 'items_total',
|
||
items_total_max: 'items_total',
|
||
sys_logistics_name: 'logistics_name',
|
||
store_name: 'shop_nick',
|
||
owner_name: 'shop_nick',
|
||
province: 'province',
|
||
sys_platform_name: 'sys_platform_name',
|
||
});
|
||
|
||
class WaveService extends OrderBaseService {
|
||
/**
|
||
* 初始化波次方法权限配置。
|
||
*
|
||
* @param {Egg.Context} ctx 请求上下文。
|
||
*/
|
||
constructor(ctx) {
|
||
super(ctx);
|
||
const _noNeedLogin = '';
|
||
const _noNeedRight = 'wavePickTaskList,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
|
||
const _noNeedLog = 'wavePickTaskList,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
|
||
const _noNeedAuth = 'wavePickTaskList,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
|
||
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<string>} 散单波次编号前缀。
|
||
*/
|
||
async getSingleFetchByIdsWavePrefix(warehouseId) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return 'A';
|
||
}
|
||
|
||
try {
|
||
const subjectConfig = await this.getWarehouseSubjectConfig(normalizedWarehouseId);
|
||
const singleFetchByIdsWavePrefix = String(
|
||
this.getWarehouseSubjectConfigValue(subjectConfig, 'delete_order_wave_prefix') || ''
|
||
).trim();
|
||
if (!singleFetchByIdsWavePrefix) {
|
||
return 'A';
|
||
}
|
||
|
||
return singleFetchByIdsWavePrefix.slice(0, 5);
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.getSingleFetchByIdsWavePrefix] 获取仓库散单波次前缀失败: %s', error.message);
|
||
return 'A';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 统一读取仓库主体配置(缓存优先,缓存 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 {number|string} [params.waveType=1] 波次类型,仅允许 1(团购)或 2(散单),非法值回退 1。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<{waveId: number, waveNo: string}>} 创建结果。
|
||
*/
|
||
async createWaveBatchReady({
|
||
warehouseId,
|
||
totalOrders,
|
||
itemDetailMachine,
|
||
itemPartType,
|
||
itemPart,
|
||
distinguishExpress,
|
||
logisticsName,
|
||
itemSnapshotKey,
|
||
wavePrefix,
|
||
waveNo,
|
||
waveType,
|
||
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();
|
||
const normalizedWaveType = Number(waveType) === 2 ? 2 : 1;
|
||
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,
|
||
:waveType,
|
||
1,
|
||
:totalOrders,
|
||
0,
|
||
:itemDetailMachine,
|
||
:itemPartType,
|
||
:itemPart,
|
||
:distinguishExpress,
|
||
:logisticsName,
|
||
:itemSnapshotKey,
|
||
:warehouseId,
|
||
:creator,
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`;
|
||
|
||
const createResult = await this.ctx.model.query(sql, {
|
||
replacements: {
|
||
waveNo: normalizedWaveNo,
|
||
waveType: normalizedWaveType,
|
||
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,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 按订单ID清理波次索引记录。
|
||
*
|
||
* @param {Object} params 清理参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Array<number|string>|number|string} params.orderIds 订单ID集合。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async deleteOrderWaveIndexByOrderIds({ warehouseId, orderIds, transaction } = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0 || normalizedOrderIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const deleteSql = `
|
||
DELETE FROM wms_order_wave_index
|
||
WHERE warehouse_id = :warehouseId
|
||
AND order_id IN (:orderIds)
|
||
`;
|
||
|
||
await this.ctx.model.query(deleteSql, {
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
orderIds: normalizedOrderIds,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 按波次ID清理波次索引记录(用于兜底)。
|
||
*
|
||
* @param {Object} params 清理参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Array<number|string>|number|string} params.waveIds 波次ID集合。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async deleteOrderWaveIndexByWaveIds({ warehouseId, waveIds, transaction } = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedWaveIds = this.normalizeIdsInput(waveIds);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0 || normalizedWaveIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const deleteSql = `
|
||
DELETE FROM wms_order_wave_index
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
`;
|
||
|
||
await this.ctx.model.query(deleteSql, {
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveIds: normalizedWaveIds,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 重建订单波次索引。
|
||
*
|
||
* 兼容历史入参校验后,统一委托按波次整批覆盖索引,
|
||
* 避免与重排流程存在两套排序规则。
|
||
*
|
||
* @param {Object} params 重建参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {number|string} params.waveId 波次ID。
|
||
* @param {Array<number|string>|number|string} params.orderIds 订单ID集合。
|
||
* @param {Object} [params.orderModel] 订单模型(可复用外层已获取模型)。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async rebuildOrderWaveIndex({ warehouseId, waveId, orderIds, orderModel, transaction } = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (
|
||
!Number.isInteger(normalizedWarehouseId)
|
||
|| normalizedWarehouseId <= 0
|
||
|| !Number.isInteger(normalizedWaveId)
|
||
|| normalizedWaveId <= 0
|
||
|| normalizedOrderIds.length === 0
|
||
) {
|
||
return;
|
||
}
|
||
await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId: normalizedWarehouseId,
|
||
waveIds: [ normalizedWaveId ],
|
||
orderModel,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 按波次整批覆盖订单索引并返回各波次当前订单数。
|
||
*
|
||
* 处理流程:
|
||
* 1. 查询目标波次下当前订单(按 wave_id ASC, id ASC)。
|
||
* 2. 先按波次批量删除 wms_order_wave_index。
|
||
* 3. 按每个波次内订单顺序重建 wave_index;platforms_index 按平台内顺序重建(同平台按 id ASC,从 1 开始)。
|
||
*
|
||
* @param {Object} params 覆盖参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Array<number|string>|number|string} params.waveIds 波次ID集合。
|
||
* @param {Object} [params.orderModel] 订单模型(可复用外层已获取模型)。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<Map<number, number>>} 波次当前订单数映射。
|
||
*/
|
||
async replaceOrderWaveIndexByWaveIds({ warehouseId, waveIds, orderModel, transaction } = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedWaveIds = this.normalizeIdsInput(waveIds);
|
||
const currentOrderModel = orderModel || await this.getOrderModel('pendingOrder', normalizedWarehouseId);
|
||
|
||
if (
|
||
!Number.isInteger(normalizedWarehouseId)
|
||
|| normalizedWarehouseId <= 0
|
||
|| normalizedWaveIds.length === 0
|
||
|| !currentOrderModel
|
||
|| typeof currentOrderModel.findAll !== 'function'
|
||
) {
|
||
return new Map();
|
||
}
|
||
|
||
const orderRows = await currentOrderModel.findAll({
|
||
attributes: [ 'id', 'wave_id', 'sys_platform_code', 'source_platform_code' ],
|
||
where: {
|
||
wave_id: {
|
||
[Op.in]: normalizedWaveIds,
|
||
[Op.gt]: 0,
|
||
},
|
||
},
|
||
order: [[ 'wave_id', 'ASC' ], [ 'id', 'ASC' ]],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
const orderRowsList = Array.isArray(orderRows) ? orderRows : [];
|
||
const waveOrderRowsMap = new Map(normalizedWaveIds.map(waveId => [ waveId, []]));
|
||
for (const row of orderRowsList) {
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
const orderId = Number(row && row.id || 0);
|
||
if (!Number.isInteger(waveId) || waveId <= 0 || !waveOrderRowsMap.has(waveId)) {
|
||
continue;
|
||
}
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
continue;
|
||
}
|
||
|
||
waveOrderRowsMap.get(waveId).push({
|
||
id: orderId,
|
||
sys_platform_code: String(row && row.sys_platform_code || ''),
|
||
source_platform_code: String(row && row.source_platform_code || ''),
|
||
});
|
||
}
|
||
|
||
await this.deleteOrderWaveIndexByWaveIds({
|
||
warehouseId: normalizedWarehouseId,
|
||
waveIds: normalizedWaveIds,
|
||
transaction,
|
||
});
|
||
|
||
const valueSqlList = [];
|
||
const replacements = {
|
||
warehouseId: normalizedWarehouseId,
|
||
};
|
||
|
||
let rowIndex = 0;
|
||
for (const waveId of normalizedWaveIds) {
|
||
const orderRowsByWave = waveOrderRowsMap.get(waveId) || [];
|
||
const platformsIndexMap = new Map();
|
||
const platformSequenceMap = new Map();
|
||
for (const orderRow of orderRowsByWave) {
|
||
const currentOrderId = Number(orderRow && orderRow.id || 0);
|
||
if (!Number.isInteger(currentOrderId) || currentOrderId <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const platformKey = String(
|
||
(orderRow && orderRow.sys_platform_code)
|
||
|| (orderRow && orderRow.source_platform_code)
|
||
|| ''
|
||
).trim().toLowerCase();
|
||
const nextPlatformSequence = Number(platformSequenceMap.get(platformKey) || 0) + 1;
|
||
platformSequenceMap.set(platformKey, nextPlatformSequence);
|
||
platformsIndexMap.set(currentOrderId, nextPlatformSequence);
|
||
}
|
||
|
||
for (const [ orderIndex, orderRow ] of orderRowsByWave.entries()) {
|
||
const orderId = Number(orderRow && orderRow.id || 0);
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
continue;
|
||
}
|
||
const waveSequence = orderIndex + 1;
|
||
const platformsSequence = Number(platformsIndexMap.get(orderId) || waveSequence);
|
||
valueSqlList.push(
|
||
`(:warehouseId, :orderId_${rowIndex}, :waveId_${rowIndex}, :waveIndex_${rowIndex}, :platformsIndex_${rowIndex}, NOW())`
|
||
);
|
||
replacements[`orderId_${rowIndex}`] = orderId;
|
||
replacements[`waveId_${rowIndex}`] = waveId;
|
||
replacements[`waveIndex_${rowIndex}`] = waveSequence;
|
||
replacements[`platformsIndex_${rowIndex}`] = platformsSequence;
|
||
rowIndex += 1;
|
||
}
|
||
}
|
||
|
||
if (valueSqlList.length > 0) {
|
||
const insertSql = `
|
||
INSERT INTO wms_order_wave_index
|
||
(
|
||
warehouse_id,
|
||
order_id,
|
||
wave_id,
|
||
wave_index,
|
||
platforms_index,
|
||
create_at
|
||
)
|
||
VALUES
|
||
${valueSqlList.join(',\n ')}
|
||
`;
|
||
|
||
await this.ctx.model.query(insertSql, {
|
||
replacements,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
const totalOrdersMap = new Map();
|
||
for (const waveId of normalizedWaveIds) {
|
||
const orderRowsByWave = waveOrderRowsMap.get(waveId) || [];
|
||
totalOrdersMap.set(waveId, orderRowsByWave.length);
|
||
}
|
||
|
||
return totalOrdersMap;
|
||
}
|
||
|
||
/**
|
||
* 构建抓取候选订单筛选条件。
|
||
*
|
||
* @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,
|
||
});
|
||
}
|
||
|
||
await this.rebuildOrderWaveIndex({
|
||
warehouseId,
|
||
waveId,
|
||
orderIds: grabbedOrderIds,
|
||
orderModel: model,
|
||
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 请求参数;兼容直接传入 pagination 对象。
|
||
* @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 {number|string} data.page 页码(直接分页对象写法)。
|
||
* @param {number|string} data.pageSize 每页数量(直接分页对象驼峰写法)。
|
||
* @param {number|string} data.page_size 每页数量(直接分页对象下划线写法)。
|
||
* @param {number|string} data.limit 每页数量(直接分页对象 limit 写法)。
|
||
* @param {number|string} data.size 每页数量(直接分页对象 size 写法)。
|
||
* @param {Object} options 规范化选项。
|
||
* @param {number|string} options.maxPageSize 每页数量上限。
|
||
* @return {{ page: number, pageSize: number }} 规范化后的分页信息。
|
||
*/
|
||
normalizePagination(data = {}, options = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
const pagination = this.isPlainObject(normalizedData.pagination) ? normalizedData.pagination : normalizedData;
|
||
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',
|
||
'source',
|
||
'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');
|
||
const source = normalizedWhere.source;
|
||
if (source !== undefined && source !== null && source !== '') {
|
||
const normalizedSource = Number(source);
|
||
if (!Number.isInteger(normalizedSource) || ![ 0, 1, 2 ].includes(normalizedSource)) {
|
||
throw new Error('source 参数不合法');
|
||
}
|
||
|
||
conditions.push('source = :whereSource');
|
||
replacements.whereSource = normalizedSource;
|
||
}
|
||
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,
|
||
};
|
||
}
|
||
/**
|
||
* 拣货任务列表查询。
|
||
*
|
||
* 基于 wms_wave_pick_task 主表按当前仓库维度分页查询,默认按 create_time 倒序。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {number|string} [data.page] 页码(兼容 current)。
|
||
* @param {number|string} [data.pageSize] 每页数量(兼容 size/page_size)。
|
||
* @param {Object} [data.where] 查询过滤。
|
||
* @return {Promise<Object>} 列表与分页结果。
|
||
*/
|
||
async wavePickTaskList(data = {}) {
|
||
try {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { page, pageSize } = this.normalizeWavePickTaskListPagination(requestData);
|
||
const normalizedRequest = this.normalizeWavePickTaskListRequest(requestData);
|
||
const warehouseId = normalizedRequest.warehouseId;
|
||
const whereClause = this.buildWavePickTaskListWhereClause(normalizedRequest.where);
|
||
const offset = (page - 1) * pageSize;
|
||
|
||
const listSql = `
|
||
SELECT
|
||
t.id,
|
||
t.task_no,
|
||
t.warehouse_id,
|
||
t.pick_mode,
|
||
t.status,
|
||
t.review_status,
|
||
t.source,
|
||
t.wave_count,
|
||
t.order_count,
|
||
t.box_count,
|
||
t.pick_user_id,
|
||
t.pick_user_name,
|
||
t.review_user_id,
|
||
t.review_user_name,
|
||
t.current_cart_id,
|
||
t.current_cart_code_snapshot,
|
||
t.batch_no,
|
||
t.device_id,
|
||
t.start_time,
|
||
t.finish_time,
|
||
t.review_start_time,
|
||
t.review_finish_time,
|
||
t.create_time,
|
||
t.update_time
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
${whereClause.sql}
|
||
ORDER BY t.create_time DESC
|
||
LIMIT :limit OFFSET :offset
|
||
`;
|
||
|
||
const countSql = `
|
||
SELECT COUNT(1) AS total
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
${whereClause.sql}
|
||
`;
|
||
|
||
const replacements = {
|
||
warehouseId,
|
||
...whereClause.replacements,
|
||
};
|
||
|
||
const [ listRows, countRows ] = await Promise.all([
|
||
this.ctx.model.query(listSql, {
|
||
replacements: {
|
||
...replacements,
|
||
limit: pageSize,
|
||
offset,
|
||
},
|
||
}),
|
||
this.ctx.model.query(countSql, {
|
||
replacements,
|
||
}),
|
||
]);
|
||
|
||
const sourceList = Array.isArray(listRows && listRows[0]) ? listRows[0] : [];
|
||
const totalRowList = Array.isArray(countRows && countRows[0]) ? countRows[0] : [];
|
||
const total = Number(totalRowList[0] && totalRowList[0].total || 0);
|
||
|
||
const list = sourceList.map(item => ({
|
||
task_id: Number(item && item.id || 0),
|
||
task_no: String(item && item.task_no || '').trim(),
|
||
warehouse_id: Number(item && item.warehouse_id || 0),
|
||
pick_mode: Number(item && item.pick_mode || 0),
|
||
status: Number(item && item.status || 0),
|
||
review_status: Number(item && item.review_status || 0),
|
||
source: Number(item && item.source || 0),
|
||
wave_count: Number(item && item.wave_count || 0),
|
||
order_count: Number(item && item.order_count || 0),
|
||
box_count: Number(item && item.box_count || 0),
|
||
pick_user_id: Number(item && item.pick_user_id || 0),
|
||
pick_user_name: String(item && item.pick_user_name || '').trim(),
|
||
operator_id: Number(item && item.pick_user_id || 0),
|
||
operator_name: String(item && item.pick_user_name || '').trim(),
|
||
review_user_id: Number(item && item.review_user_id || 0),
|
||
review_user_name: String(item && item.review_user_name || '').trim(),
|
||
current_cart_id: Number(item && item.current_cart_id || 0),
|
||
current_cart_code_snapshot: String(item && item.current_cart_code_snapshot || '').trim(),
|
||
batch_no: String(item && item.batch_no || '').trim(),
|
||
device_id: String(item && item.device_id || '').trim(),
|
||
start_time: item && item.start_time || null,
|
||
start_at: item && item.start_time || null,
|
||
finish_time: item && item.finish_time || null,
|
||
finish_at: item && item.finish_time || null,
|
||
review_start_time: item && item.review_start_time || null,
|
||
review_finish_time: item && item.review_finish_time || null,
|
||
create_time: item && item.create_time || null,
|
||
created_at: item && item.create_time || null,
|
||
update_time: item && item.update_time || null,
|
||
}));
|
||
|
||
return this.success('ok', {
|
||
list,
|
||
total,
|
||
page,
|
||
page_size: pageSize,
|
||
});
|
||
} catch (error) {
|
||
const errorMessage = String(error && error.message || '').trim();
|
||
const isBadRequest = /参数|上下文/.test(errorMessage);
|
||
return this.fail(`查询拣货任务列表失败: ${errorMessage || '未知错误'}`, isBadRequest ? 400 : 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解析拣货任务列表分页参数。
|
||
*
|
||
* 兼容 current/size 写法,并复用通用分页归一化能力。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @return {{ page: number, pageSize: number }} 归一化分页。
|
||
*/
|
||
normalizeWavePickTaskListPagination(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
const pagination = this.isPlainObject(normalizedData.pagination)
|
||
? normalizedData.pagination
|
||
: normalizedData;
|
||
|
||
const pageSource = pagination.page ?? pagination.page_no ?? pagination.pageNo ?? pagination.current;
|
||
const pageSizeSource = pagination.pageSize ?? pagination.page_size ?? pagination.size;
|
||
|
||
return this.normalizePagination({
|
||
page: pageSource,
|
||
pageSize: pageSizeSource,
|
||
});
|
||
}
|
||
|
||
|
||
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(' | ');
|
||
}
|
||
|
||
/**
|
||
* 构建订单商品快照字符串。
|
||
*
|
||
* 输出格式:商品名称1*数量|商品名称2*数量。
|
||
*
|
||
* @param {Array<Object>} itemDetails 商品明细列表。
|
||
* @return {string} 商品快照字符串。
|
||
*/
|
||
buildOrderItemSnapshot(itemDetails = []) {
|
||
if (!Array.isArray(itemDetails) || itemDetails.length === 0) {
|
||
return '';
|
||
}
|
||
|
||
const segments = itemDetails
|
||
.map(item => {
|
||
const itemName = String(item && (item.item_name || item.item_code) || '').trim();
|
||
const quantity = Number(item && item.quantity || 0);
|
||
if (!itemName || !Number.isFinite(quantity) || quantity <= 0) {
|
||
return '';
|
||
}
|
||
|
||
return `${itemName}*${quantity}`;
|
||
})
|
||
.filter(Boolean);
|
||
|
||
return segments.join('|');
|
||
}
|
||
|
||
|
||
/**
|
||
* 归一化拣货任务列表请求参数。
|
||
*
|
||
* 兼容顶层筛选参数与 where 结构并保持旧调用可用:
|
||
* - 顶层支持 warehouse_id/status/source/keyword/task_no
|
||
* - 同名字段优先使用顶层值覆盖 where
|
||
* - warehouse_id 未传时回退当前仓库上下文
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @return {{ warehouseId: number, where: Object }} 归一化仓库与查询条件。
|
||
*/
|
||
normalizeWavePickTaskListRequest(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const baseWhere = this.isPlainObject(requestData.where) ? { ...requestData.where } : {};
|
||
|
||
const mergeFieldFromTopLevel = fieldName => {
|
||
if (Object.prototype.hasOwnProperty.call(requestData, fieldName)) {
|
||
baseWhere[fieldName] = requestData[fieldName];
|
||
}
|
||
};
|
||
|
||
[
|
||
'status',
|
||
'source',
|
||
'keyword',
|
||
'task_no',
|
||
'pick_mode',
|
||
'review_status',
|
||
'pick_user_id',
|
||
'review_user_id',
|
||
'cart_id',
|
||
'start_time_start',
|
||
'start_time_end',
|
||
].forEach(mergeFieldFromTopLevel);
|
||
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
const inputWarehouseId = requestData.warehouse_id ?? requestData.warehouseId;
|
||
const warehouseId = inputWarehouseId !== undefined && inputWarehouseId !== null && inputWarehouseId !== ''
|
||
? Number(inputWarehouseId)
|
||
: contextWarehouseId;
|
||
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw new Error('warehouse_id 参数不合法');
|
||
}
|
||
|
||
if (Number.isInteger(contextWarehouseId)
|
||
&& contextWarehouseId > 0
|
||
&& inputWarehouseId !== undefined
|
||
&& inputWarehouseId !== null
|
||
&& inputWarehouseId !== ''
|
||
&& warehouseId !== contextWarehouseId) {
|
||
throw new Error('warehouse_id 与当前仓库上下文不一致');
|
||
}
|
||
|
||
return {
|
||
warehouseId,
|
||
where: baseWhere,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建拣货任务列表 where 条件(白名单字段)。
|
||
*
|
||
* 注意:当前 wms_wave_pick_task 主表未落 strategy_id 字段,
|
||
* 因此 strategy_id 过滤入参会被忽略,不参与 SQL 条件拼接。
|
||
*
|
||
* @param {Object} whereData 查询 where 入参。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildWavePickTaskListWhereClause(whereData = {}) {
|
||
const normalizedWhere = this.isPlainObject(whereData) ? whereData : {};
|
||
const whereKeys = Object.keys(normalizedWhere);
|
||
const allowedFields = [
|
||
'status',
|
||
'review_status',
|
||
'pick_mode',
|
||
'source',
|
||
'strategy_id',
|
||
'pick_user_id',
|
||
'review_user_id',
|
||
'task_no',
|
||
'cart_id',
|
||
'keyword',
|
||
'start_time_start',
|
||
'start_time_end',
|
||
];
|
||
|
||
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 status = normalizedWhere.status;
|
||
if (Array.isArray(status)) {
|
||
const normalizedStatusList = [ ...new Set(status
|
||
.map(value => Number(value))
|
||
.filter(value => Number.isInteger(value) && value >= 0)) ];
|
||
if (normalizedStatusList.length <= 0) {
|
||
throw new Error('status 参数不合法');
|
||
}
|
||
|
||
conditions.push('t.status IN (:whereStatusList)');
|
||
replacements.whereStatusList = normalizedStatusList;
|
||
} else {
|
||
appendIntegerEqualCondition('status', 't.status', 'whereStatus');
|
||
}
|
||
appendIntegerEqualCondition('review_status', 't.review_status', 'whereReviewStatus');
|
||
appendIntegerEqualCondition('pick_mode', 't.pick_mode', 'wherePickMode', false);
|
||
appendIntegerEqualCondition('source', 't.source', 'whereSource', false);
|
||
appendIntegerEqualCondition('pick_user_id', 't.pick_user_id', 'wherePickUserId');
|
||
appendIntegerEqualCondition('review_user_id', 't.review_user_id', 'whereReviewUserId');
|
||
appendIntegerEqualCondition('cart_id', 't.current_cart_id', 'whereCartId', false);
|
||
|
||
const taskNo = normalizedWhere.task_no;
|
||
if (taskNo !== undefined && taskNo !== null && taskNo !== '') {
|
||
const normalizedTaskNo = String(taskNo).trim();
|
||
if (!normalizedTaskNo) {
|
||
throw new Error('task_no 参数不合法');
|
||
}
|
||
|
||
conditions.push('t.task_no LIKE :whereTaskNo');
|
||
replacements.whereTaskNo = `%${normalizedTaskNo}%`;
|
||
}
|
||
|
||
const keyword = normalizedWhere.keyword;
|
||
if (keyword !== undefined && keyword !== null && keyword !== '') {
|
||
const normalizedKeyword = String(keyword).trim();
|
||
if (!normalizedKeyword) {
|
||
throw new Error('keyword 参数不合法');
|
||
}
|
||
|
||
conditions.push(`(
|
||
t.task_no LIKE :whereKeyword
|
||
OR t.pick_user_name LIKE :whereKeyword
|
||
OR t.review_user_name LIKE :whereKeyword
|
||
OR t.batch_no LIKE :whereKeyword
|
||
)`);
|
||
replacements.whereKeyword = `%${normalizedKeyword}%`;
|
||
}
|
||
|
||
const startTimeStart = normalizedWhere.start_time_start;
|
||
if (startTimeStart !== undefined && startTimeStart !== null && startTimeStart !== '') {
|
||
const normalizedStartTimeStart = String(startTimeStart).trim();
|
||
const startDate = new Date(normalizedStartTimeStart);
|
||
if (!normalizedStartTimeStart || Number.isNaN(startDate.getTime())) {
|
||
throw new Error('start_time_start 参数不合法');
|
||
}
|
||
|
||
conditions.push('t.create_time >= :whereCreateTimeStart');
|
||
replacements.whereCreateTimeStart = normalizedStartTimeStart;
|
||
}
|
||
|
||
const startTimeEnd = normalizedWhere.start_time_end;
|
||
if (startTimeEnd !== undefined && startTimeEnd !== null && startTimeEnd !== '') {
|
||
const normalizedStartTimeEnd = String(startTimeEnd).trim();
|
||
const endDate = new Date(normalizedStartTimeEnd);
|
||
if (!normalizedStartTimeEnd || Number.isNaN(endDate.getTime())) {
|
||
throw new Error('start_time_end 参数不合法');
|
||
}
|
||
|
||
conditions.push('t.create_time <= :whereCreateTimeEnd');
|
||
replacements.whereCreateTimeEnd = normalizedStartTimeEnd;
|
||
}
|
||
|
||
return {
|
||
sql: conditions.length > 0 ? `\n AND ${conditions.join('\n AND ')}` : '',
|
||
replacements,
|
||
};
|
||
}
|
||
|
||
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,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 查询当前仓库波次策略列表。
|
||
*
|
||
* 仅查询当前登录仓库在 wms_wave_strategy 中的数据,返回标准 list/pagination 结构。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {Object} [data.pagination] 分页参数。
|
||
* @return {Promise<Object>} 波次策略列表及分页信息。
|
||
*/
|
||
async waveStrategyList(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { page, pageSize } = this.normalizePagination(requestData);
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const strategyModel = this.getWaveStrategyModel();
|
||
if (!strategyModel || typeof strategyModel.findAndCountAll !== 'function') {
|
||
throw new Error('波次策略模型不可用');
|
||
}
|
||
|
||
const offset = (page - 1) * pageSize;
|
||
const queryResult = await strategyModel.findAndCountAll({
|
||
where: {
|
||
warehouse_id: contextWarehouseId,
|
||
},
|
||
order: [
|
||
[ 'status', 'DESC' ],
|
||
[ 'id', 'DESC' ],
|
||
],
|
||
offset,
|
||
limit: pageSize,
|
||
raw: true,
|
||
});
|
||
|
||
const list = Array.isArray(queryResult && queryResult.rows) ? queryResult.rows : [];
|
||
const total = Number(queryResult && queryResult.count || 0);
|
||
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
|
||
|
||
return this.success('ok', {
|
||
list,
|
||
pagination: {
|
||
page,
|
||
pageSize,
|
||
total,
|
||
totalPages,
|
||
hasPrevious: page > 1,
|
||
hasNext: page < totalPages,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 新增波次策略。
|
||
*
|
||
* warehouse_id 与 creator_name 强制使用当前上下文,不接受外部覆盖。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @return {Promise<Object>} 新增结果。
|
||
*/
|
||
async waveStrategyCreate(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const warehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const strategyModel = this.getWaveStrategyModel();
|
||
if (!strategyModel || typeof strategyModel.create !== 'function') {
|
||
throw new Error('波次策略模型不可用');
|
||
}
|
||
|
||
const payload = await this.normalizeWaveStrategyUpsertPayload(requestData, {
|
||
warehouseId,
|
||
mode: 'create',
|
||
});
|
||
const operator = this.getOrderLogOperator();
|
||
const transaction = await this.ctx.model.transaction();
|
||
let created;
|
||
try {
|
||
created = await strategyModel.create({
|
||
...payload,
|
||
warehouse_id: warehouseId,
|
||
creator_name: String(operator && operator.name || 'system').trim() || 'system',
|
||
}, {
|
||
transaction,
|
||
});
|
||
|
||
await this.bumpWaveStrategyVersionAndInvalidateCache(warehouseId, { transaction });
|
||
await transaction.commit();
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
|
||
const createdData = created && typeof created.get === 'function' ? created.get({ plain: true }) : created;
|
||
|
||
return this.success('ok', { data: createdData, code: 200 });
|
||
}
|
||
|
||
/**
|
||
* 修改波次策略。
|
||
*
|
||
* warehouse_id 与 creator_name 强制使用当前上下文,不接受外部覆盖。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @return {Promise<Object>} 修改结果。
|
||
*/
|
||
async waveStrategyUpdate(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const warehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const strategyModel = this.getWaveStrategyModel();
|
||
if (!strategyModel || typeof strategyModel.findOne !== 'function' || typeof strategyModel.update !== 'function') {
|
||
throw new Error('波次策略模型不可用');
|
||
}
|
||
|
||
const strategyId = this.normalizeWaveStrategyId(requestData);
|
||
const payload = await this.normalizeWaveStrategyUpsertPayload(requestData, {
|
||
warehouseId,
|
||
mode: 'update',
|
||
});
|
||
if (Object.keys(payload).length === 0) {
|
||
throw new Error('缺少可更新字段');
|
||
}
|
||
|
||
const operator = this.getOrderLogOperator();
|
||
const transaction = await this.ctx.model.transaction();
|
||
let updated;
|
||
try {
|
||
const exists = await strategyModel.findOne({
|
||
where: {
|
||
id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
},
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
if (!exists) {
|
||
throw new Error(`波次策略不存在: ${strategyId}`);
|
||
}
|
||
|
||
await strategyModel.update({
|
||
...payload,
|
||
creator_name: String(operator && operator.name || 'system').trim() || 'system',
|
||
update_time: new Date(),
|
||
}, {
|
||
where: {
|
||
id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
await this.bumpWaveStrategyVersionAndInvalidateCache(warehouseId, { transaction });
|
||
|
||
updated = await strategyModel.findOne({
|
||
where: {
|
||
id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
},
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
await transaction.commit();
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
|
||
return this.success('ok', { data: updated || null, code: 200 });
|
||
}
|
||
|
||
/**
|
||
* 递增仓库波次策略版本并失效相关缓存。
|
||
*
|
||
* 数据更新在事务内执行;当传入事务时,缓存失效动作会在事务提交后执行。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {Object} [options={}] 处理选项。
|
||
* @param {Object} [options.transaction] Sequelize 事务对象。
|
||
* @return {Promise<number>} 自增后的版本号。
|
||
*/
|
||
async bumpWaveStrategyVersionAndInvalidateCache(warehouseId, options = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const { transaction } = this.isPlainObject(options) ? options : {};
|
||
const settingWarehouseService = this.ctx.service
|
||
&& this.ctx.service.systems
|
||
&& this.ctx.service.systems.setting
|
||
&& this.ctx.service.systems.setting.warehouse;
|
||
const modelContainer = this.ctx.model || this.app.model || {};
|
||
const storeModel = modelContainer.Store;
|
||
|
||
if (!storeModel || typeof storeModel.findByPk !== 'function') {
|
||
throw new Error('Store model 不可用');
|
||
}
|
||
|
||
const storeQueryOptions = {
|
||
attributes: [ 'id', 'subject_config' ],
|
||
};
|
||
if (transaction) {
|
||
storeQueryOptions.transaction = transaction;
|
||
if (transaction.LOCK && transaction.LOCK.UPDATE) {
|
||
storeQueryOptions.lock = transaction.LOCK.UPDATE;
|
||
}
|
||
}
|
||
|
||
const store = await storeModel.findByPk(normalizedWarehouseId, storeQueryOptions);
|
||
if (!store) {
|
||
throw new Error(`仓库不存在: ${normalizedWarehouseId}`);
|
||
}
|
||
|
||
const currentSubjectConfig = store.subject_config && typeof store.subject_config === 'object' && !Array.isArray(store.subject_config)
|
||
? { ...store.subject_config }
|
||
: {};
|
||
const normalizedSubjectConfig = settingWarehouseService
|
||
&& typeof settingWarehouseService.normalizeSubjectConfigInternalFields === 'function'
|
||
? settingWarehouseService.normalizeSubjectConfigInternalFields(currentSubjectConfig)
|
||
: currentSubjectConfig;
|
||
const currentVersion = settingWarehouseService
|
||
&& typeof settingWarehouseService.normalizeWaveStrategyVersion === 'function'
|
||
? settingWarehouseService.normalizeWaveStrategyVersion(normalizedSubjectConfig.wave_strategy_version, { useDefaultWhenEmpty: true })
|
||
: Number(normalizedSubjectConfig.wave_strategy_version || 1);
|
||
|
||
if (!Number.isSafeInteger(currentVersion) || currentVersion < 0) {
|
||
throw new Error('subject_config.wave_strategy_version 必须是非负整数');
|
||
}
|
||
if (currentVersion >= Number.MAX_SAFE_INTEGER) {
|
||
throw new Error('subject_config.wave_strategy_version 超出安全整数范围');
|
||
}
|
||
|
||
const nextVersion = currentVersion + 1;
|
||
normalizedSubjectConfig.wave_strategy_version = nextVersion;
|
||
|
||
const subjectConfigForUpdate = typeof storeModel.normalizeSubjectConfig === 'function'
|
||
? storeModel.normalizeSubjectConfig(normalizedSubjectConfig)
|
||
: normalizedSubjectConfig;
|
||
|
||
await store.update({
|
||
subject_config: subjectConfigForUpdate,
|
||
}, {
|
||
...(transaction ? { transaction } : {}),
|
||
});
|
||
|
||
const invalidateCache = async () => {
|
||
if (settingWarehouseService && typeof settingWarehouseService.clearWarehouseSettingCache === 'function') {
|
||
await settingWarehouseService.clearWarehouseSettingCache(normalizedWarehouseId);
|
||
}
|
||
|
||
const deliveryOrderService = this.ctx.service
|
||
&& this.ctx.service.systems
|
||
&& this.ctx.service.systems.deliveryOrder;
|
||
const subjectConfigCacheKey = deliveryOrderService
|
||
&& typeof deliveryOrderService.getStoreSubjectConfigCacheKey === 'function'
|
||
? deliveryOrderService.getStoreSubjectConfigCacheKey(normalizedWarehouseId)
|
||
: `delivery_order:store:${normalizedWarehouseId}:subject_config`;
|
||
|
||
if (subjectConfigCacheKey) {
|
||
if (this.app && typeof this.app.delCacheAsync === 'function') {
|
||
await this.app.delCacheAsync(subjectConfigCacheKey);
|
||
} else if (this.app && typeof this.app.setCacheAsync === 'function') {
|
||
await this.app.setCacheAsync(subjectConfigCacheKey, null, 0);
|
||
}
|
||
}
|
||
};
|
||
|
||
if (transaction && typeof transaction.afterCommit === 'function') {
|
||
transaction.afterCommit(async () => {
|
||
await invalidateCache();
|
||
});
|
||
} else {
|
||
await invalidateCache();
|
||
}
|
||
|
||
return nextVersion;
|
||
}
|
||
|
||
/**
|
||
* 获取波次策略模型。
|
||
*
|
||
* @return {Object|null} 模型对象。
|
||
*/
|
||
getWaveStrategyModel() {
|
||
return this.ctx.model && (
|
||
this.ctx.model.wms_wave_strategy
|
||
|| this.ctx.model.PickingStrategy
|
||
|| this.ctx.model.WmsWaveStrategy
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 归一化波次策略主键。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @return {number} 策略主键。
|
||
*/
|
||
normalizeWaveStrategyId(data = {}) {
|
||
const rawId = data && (data.id ?? data.strategy_id ?? data.strategyId);
|
||
return this.normalizeRequiredPositiveInteger(rawId, 'id');
|
||
}
|
||
|
||
/**
|
||
* 归一化波次策略新增/修改入参并执行统一校验。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Object} options 处理选项。
|
||
* @param {number} options.warehouseId 当前仓库ID。
|
||
* @param {string} options.mode 模式:create/update。
|
||
* @return {Promise<Object>} 可直接写库的载荷。
|
||
*/
|
||
async normalizeWaveStrategyUpsertPayload(data = {}, options = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const mode = String(options && options.mode || '').trim().toLowerCase();
|
||
const warehouseId = Number(options && options.warehouseId || 0);
|
||
const payload = {};
|
||
|
||
if (mode === 'create') {
|
||
const strategyName = String(requestData.strategy_name || '').trim();
|
||
if (!strategyName) {
|
||
throw new Error('strategy_name 参数不能为空');
|
||
}
|
||
payload.strategy_name = strategyName;
|
||
payload.strategy_type = this.normalizeRequiredPositiveInteger(requestData.strategy_type, 'strategy_type');
|
||
payload.batch_mode = this.normalizeRequiredPositiveInteger(requestData.batch_mode, 'batch_mode');
|
||
} else {
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'strategy_name')) {
|
||
const strategyName = String(requestData.strategy_name || '').trim();
|
||
if (!strategyName) {
|
||
throw new Error('strategy_name 参数不能为空');
|
||
}
|
||
payload.strategy_name = strategyName;
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'strategy_type')) {
|
||
payload.strategy_type = this.normalizeRequiredPositiveInteger(requestData.strategy_type, 'strategy_type');
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'batch_mode')) {
|
||
payload.batch_mode = this.normalizeRequiredPositiveInteger(requestData.batch_mode, 'batch_mode');
|
||
}
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'status')) {
|
||
const normalizedStatus = Number(requestData.status);
|
||
if (![ 0, 1 ].includes(normalizedStatus)) {
|
||
throw new Error('status 参数不合法,仅支持 0 或 1');
|
||
}
|
||
payload.status = normalizedStatus;
|
||
}
|
||
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'order_min_sku');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'order_max_sku');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'order_min_qty');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'order_max_qty');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'min_same_structure');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'max_same_structure');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'batch_max_orders');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'batch_max_skus');
|
||
this.patchWaveStrategyIntegerField(payload, requestData, 'group_batch_max_orders');
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'require_same_express')) {
|
||
payload.require_same_express = this.normalizeBoolean(requestData.require_same_express, false);
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allow_cross_owner')) {
|
||
payload.allow_cross_owner = this.normalizeBoolean(requestData.allow_cross_owner, true);
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'description')) {
|
||
payload.description = String(requestData.description || '').trim();
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_provinces')) {
|
||
payload.allowed_provinces = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_provinces);
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_platforms')) {
|
||
payload.allowed_platforms = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_platforms);
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_owners')) {
|
||
const allowedOwners = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_owners);
|
||
await this.validateWaveStrategyAllowedOwners(allowedOwners, warehouseId);
|
||
payload.allowed_owners = allowedOwners;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_expresses')) {
|
||
const allowedExpresses = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_expresses);
|
||
await this.validateWaveStrategyAllowedExpresses(allowedExpresses);
|
||
payload.allowed_expresses = allowedExpresses;
|
||
}
|
||
|
||
await this.applyWaveStrategyMaxSameStructureConstraint(payload, warehouseId);
|
||
|
||
delete payload.warehouse_id;
|
||
delete payload.creator;
|
||
delete payload.creator_name;
|
||
|
||
return payload;
|
||
}
|
||
|
||
/**
|
||
* 按字段补丁方式归一化波次策略正整数参数。
|
||
*
|
||
* @param {Object} payload 输出载荷。
|
||
* @param {Object} requestData 原始请求。
|
||
* @param {string} fieldName 字段名。
|
||
*/
|
||
patchWaveStrategyIntegerField(payload = {}, requestData = {}, fieldName = '') {
|
||
if (!Object.prototype.hasOwnProperty.call(requestData, fieldName)) {
|
||
return;
|
||
}
|
||
|
||
const rawValue = requestData[fieldName];
|
||
if (rawValue === null || rawValue === '') {
|
||
payload[fieldName] = null;
|
||
return;
|
||
}
|
||
|
||
payload[fieldName] = this.normalizeRequiredPositiveInteger(rawValue, fieldName);
|
||
}
|
||
|
||
/**
|
||
* 校验 allowed_owners 是否在系统可用货主范围内。
|
||
*
|
||
* @param {Array<string>} ownerList 货主列表。
|
||
* @param {number} warehouseId 当前仓库ID。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async validateWaveStrategyAllowedOwners(ownerList = [], warehouseId = 0) {
|
||
const normalizedOwners = Array.isArray(ownerList)
|
||
? ownerList.map(item => String(item || '').trim().toLowerCase()).filter(Boolean)
|
||
: [];
|
||
if (normalizedOwners.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const availableOwnerSet = await this.getWaveStrategyAvailableOwnerSet(warehouseId);
|
||
const illegalOwners = normalizedOwners.filter(item => !availableOwnerSet.has(item));
|
||
|
||
if (illegalOwners.length > 0) {
|
||
throw new Error(`allowed_owners 存在非法值: ${illegalOwners.join(', ')}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 校验 allowed_expresses 是否在系统可用快递范围内。
|
||
*
|
||
* @param {Array<string>} expressList 快递编码列表。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async validateWaveStrategyAllowedExpresses(expressList = []) {
|
||
const normalizedExpresses = Array.isArray(expressList)
|
||
? expressList.map(item => String(item || '').trim().toLowerCase()).filter(Boolean)
|
||
: [];
|
||
if (normalizedExpresses.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const availableExpressSet = await this.getWaveStrategyAvailableExpressSet();
|
||
const illegalExpresses = normalizedExpresses.filter(item => !availableExpressSet.has(item));
|
||
|
||
if (illegalExpresses.length > 0) {
|
||
throw new Error(`allowed_expresses 存在非法值: ${illegalExpresses.join(', ')}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取当前仓库可用货主集合。
|
||
*
|
||
* 优先复用 systems.store.loadStores,若不可用则回退查询签约表。
|
||
*
|
||
* @param {number} warehouseId 当前仓库ID。
|
||
* @return {Promise<Set<string>>} 货主集合(小写字符串)。
|
||
*/
|
||
async getWaveStrategyAvailableOwnerSet(warehouseId = 0) {
|
||
const availableSet = new Set();
|
||
const storeService = this.ctx.service
|
||
&& this.ctx.service.systems
|
||
&& this.ctx.service.systems.store;
|
||
|
||
if (storeService && typeof storeService.loadStores === 'function') {
|
||
const rows = await storeService.loadStores();
|
||
for (const row of Array.isArray(rows) ? rows : []) {
|
||
const ownerId = String(row && (row.value ?? row.store_id) || '').trim().toLowerCase();
|
||
if (ownerId) {
|
||
availableSet.add(ownerId);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (availableSet.size > 0) {
|
||
return availableSet;
|
||
}
|
||
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const storeWarehouseModel = this.ctx.model && this.ctx.model.StoreWarehouse;
|
||
if (!storeWarehouseModel || typeof storeWarehouseModel.findAll !== 'function') {
|
||
return availableSet;
|
||
}
|
||
|
||
const rows = await storeWarehouseModel.findAll({
|
||
attributes: [ 'store_id' ],
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
use_status: 1,
|
||
},
|
||
raw: true,
|
||
});
|
||
|
||
for (const row of Array.isArray(rows) ? rows : []) {
|
||
const ownerId = String(row && row.store_id || '').trim().toLowerCase();
|
||
if (ownerId) {
|
||
availableSet.add(ownerId);
|
||
}
|
||
}
|
||
|
||
return availableSet;
|
||
}
|
||
|
||
/**
|
||
* 获取当前仓库可用快递编码集合。
|
||
*
|
||
* 优先复用 systems.express.getExpressList,若不可用则回退系统快递表。
|
||
*
|
||
* @return {Promise<Set<string>>} 快递编码集合(小写字符串)。
|
||
*/
|
||
async getWaveStrategyAvailableExpressSet() {
|
||
const availableSet = new Set();
|
||
const expressService = this.ctx.service
|
||
&& this.ctx.service.systems
|
||
&& this.ctx.service.systems.express;
|
||
|
||
if (expressService && typeof expressService.getExpressList === 'function') {
|
||
const rows = await expressService.getExpressList();
|
||
for (const row of Array.isArray(rows) ? rows : []) {
|
||
const code = String(row && (row.code || row.value) || '').trim().toLowerCase();
|
||
if (code) {
|
||
availableSet.add(code);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (availableSet.size > 0) {
|
||
return availableSet;
|
||
}
|
||
|
||
const expressModel = this.ctx.model && this.ctx.model.Express;
|
||
if (!expressModel || typeof expressModel.findAll !== 'function') {
|
||
return availableSet;
|
||
}
|
||
|
||
const rows = await expressModel.findAll({
|
||
attributes: [ 'code' ],
|
||
order: [[ 'code', 'ASC' ]],
|
||
raw: true,
|
||
});
|
||
|
||
for (const row of Array.isArray(rows) ? rows : []) {
|
||
const code = String(row && row.code || '').trim().toLowerCase();
|
||
if (code) {
|
||
availableSet.add(code);
|
||
}
|
||
}
|
||
|
||
return availableSet;
|
||
}
|
||
|
||
/**
|
||
* 按仓库最小团购抓取量约束 max_same_structure。
|
||
*
|
||
* 当 min_group_order_fetch_quantity 为有效正整数且
|
||
* max_same_structure >= min_group_order_fetch_quantity 时,
|
||
* 自动下调为 min_group_order_fetch_quantity - 1,且最小保持为 1。
|
||
*
|
||
* @param {Object} payload 目标写库载荷。
|
||
* @param {number} warehouseId 当前仓库ID。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async applyWaveStrategyMaxSameStructureConstraint(payload = {}, warehouseId = 0) {
|
||
if (!Object.prototype.hasOwnProperty.call(payload, 'max_same_structure')) {
|
||
return;
|
||
}
|
||
|
||
const maxSameStructure = payload.max_same_structure;
|
||
if (maxSameStructure === null || maxSameStructure === undefined || maxSameStructure === '') {
|
||
return;
|
||
}
|
||
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return;
|
||
}
|
||
|
||
const subjectConfig = await this.getWarehouseSubjectConfig(normalizedWarehouseId);
|
||
const minGroupOrderFetchQuantity = Number(
|
||
this.getWarehouseSubjectConfigValue(subjectConfig, 'min_group_order_fetch_quantity')
|
||
);
|
||
if (!Number.isInteger(minGroupOrderFetchQuantity) || minGroupOrderFetchQuantity <= 0) {
|
||
return;
|
||
}
|
||
|
||
const normalizedMaxSameStructure = Number(maxSameStructure);
|
||
if (!Number.isInteger(normalizedMaxSameStructure) || normalizedMaxSameStructure <= 0) {
|
||
throw new Error('max_same_structure 参数必须为正整数');
|
||
}
|
||
|
||
if (normalizedMaxSameStructure >= minGroupOrderFetchQuantity) {
|
||
payload.max_same_structure = Math.max(minGroupOrderFetchQuantity - 1, 1);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 校验并标准化兜底订单列表 where 白名单字段。
|
||
*
|
||
* 仅允许与波次策略过滤直接相关的字段;对兼容别名做统一映射,
|
||
* 例如 delivery_no -> delivery_order_code、tracking_no -> express_numbers。
|
||
*
|
||
* @param {Object} whereData 原始 where 入参。
|
||
* @return {Object} 标准化后的 where 条件。
|
||
*/
|
||
normalizeWaveStrategyFallbackOrderListWhere(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 = Object.keys(WAVE_STRATEGY_FALLBACK_WHERE_FIELD_MAP);
|
||
const invalidFields = whereKeys.filter(key => !allowedFields.includes(key));
|
||
if (invalidFields.length > 0) {
|
||
throw new Error(`where 存在不支持的字段: ${invalidFields.join(',')}`);
|
||
}
|
||
|
||
const hasStoreName = Object.prototype.hasOwnProperty.call(normalizedWhere, 'store_name');
|
||
const hasOwnerName = Object.prototype.hasOwnProperty.call(normalizedWhere, 'owner_name');
|
||
if (hasStoreName && hasOwnerName) {
|
||
throw new Error('store_name 与 owner_name 不能同时传入,请保留一个货主名称字段');
|
||
}
|
||
|
||
const rangeOperatorMap = Object.freeze({
|
||
items_count_min: 'ge',
|
||
items_count_max: 'le',
|
||
items_total_min: 'ge',
|
||
items_total_max: 'le',
|
||
});
|
||
const mappedWhere = {};
|
||
for (const field of allowedFields) {
|
||
if (!Object.prototype.hasOwnProperty.call(normalizedWhere, field)) {
|
||
continue;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(rangeOperatorMap, field)) {
|
||
const rawValue = normalizedWhere[field];
|
||
const value = this.isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, 'value')
|
||
? rawValue.value
|
||
: rawValue;
|
||
mappedWhere[field] = {
|
||
operator: rangeOperatorMap[field],
|
||
field: WAVE_STRATEGY_FALLBACK_WHERE_FIELD_MAP[field],
|
||
value,
|
||
};
|
||
continue;
|
||
}
|
||
|
||
mappedWhere[WAVE_STRATEGY_FALLBACK_WHERE_FIELD_MAP[field]] = normalizedWhere[field];
|
||
}
|
||
|
||
return mappedWhere;
|
||
}
|
||
|
||
/**
|
||
* 解析兜底订单列表中的快递号展示值。
|
||
*
|
||
* @param {Object} orderRow 订单行。
|
||
* @return {string|null} 快递号。
|
||
*/
|
||
resolveWaveStrategyFallbackTrackingNo(orderRow = {}) {
|
||
if (!this.isPlainObject(orderRow)) {
|
||
return null;
|
||
}
|
||
|
||
const directTrackingNo = String(orderRow.tracking_no || '').trim();
|
||
if (directTrackingNo) {
|
||
return directTrackingNo;
|
||
}
|
||
|
||
const expressNumbers = Array.isArray(orderRow.express_numbers)
|
||
? orderRow.express_numbers
|
||
: Array.isArray(orderRow.waybill_codes)
|
||
? orderRow.waybill_codes
|
||
: [];
|
||
const normalizedExpressNumbers = expressNumbers
|
||
.map(item => String(item || '').trim())
|
||
.filter(Boolean);
|
||
|
||
if (normalizedExpressNumbers.length > 0) {
|
||
return normalizedExpressNumbers[0];
|
||
}
|
||
|
||
const expressNumbersText = String(orderRow.express_numbers || '').trim();
|
||
if (expressNumbersText) {
|
||
return expressNumbersText.split(',').map(item => item.trim()).filter(Boolean)[0] || null;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 解析兜底订单列表中的货主名称展示值。
|
||
*
|
||
* @param {Object} orderRow 订单行。
|
||
* @return {string|null} 货主名称。
|
||
*/
|
||
resolveWaveStrategyFallbackStoreName(orderRow = {}) {
|
||
if (!this.isPlainObject(orderRow)) {
|
||
return null;
|
||
}
|
||
|
||
const candidateList = [
|
||
orderRow.store_name,
|
||
orderRow.owner_name,
|
||
orderRow.shop_nick,
|
||
orderRow.seller_nick,
|
||
];
|
||
|
||
for (const candidate of candidateList) {
|
||
const normalizedValue = String(candidate || '').trim();
|
||
if (normalizedValue) {
|
||
return normalizedValue;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 解析兜底订单列表中的系统快递名称。
|
||
*
|
||
* @param {Object} orderRow 订单行。
|
||
* @return {string|null} 系统快递名称。
|
||
*/
|
||
resolveWaveStrategyFallbackSysLogisticsName(orderRow = {}) {
|
||
if (!this.isPlainObject(orderRow)) {
|
||
return null;
|
||
}
|
||
|
||
const candidateList = [ orderRow.sys_logistics_name, orderRow.logistics_name ];
|
||
for (const candidate of candidateList) {
|
||
const normalizedValue = String(candidate || '').trim();
|
||
if (normalizedValue) {
|
||
return normalizedValue;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 构建兜底订单列表单行输出,仅保留波次策略相关字段。
|
||
*
|
||
* @param {Object} orderRow 原始订单行。
|
||
* @param {string} itemSnapshot 商品快照文本。
|
||
* @return {Object} 裁剪后的订单行。
|
||
*/
|
||
buildWaveStrategyFallbackOrderListItem(orderRow = {}, itemSnapshot = '') {
|
||
const normalizedOrderRow = this.isPlainObject(orderRow) ? orderRow : {};
|
||
|
||
return {
|
||
id: normalizedOrderRow.id ?? null,
|
||
delivery_no: normalizedOrderRow.delivery_no ?? normalizedOrderRow.delivery_order_code ?? null,
|
||
tracking_no: this.resolveWaveStrategyFallbackTrackingNo(normalizedOrderRow),
|
||
items_count: normalizedOrderRow.items_count ?? null,
|
||
items_total: normalizedOrderRow.items_total ?? null,
|
||
sys_logistics_name: this.resolveWaveStrategyFallbackSysLogisticsName(normalizedOrderRow),
|
||
store_name: this.resolveWaveStrategyFallbackStoreName(normalizedOrderRow),
|
||
province: normalizedOrderRow.province ?? null,
|
||
sys_platform_name: normalizedOrderRow.sys_platform_name ?? null,
|
||
item_snapshot: String(itemSnapshot || ''),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 查询兜底不符合波次策略的订单列表。
|
||
*
|
||
* 直接复用订单通用列表能力,返回标准 list/pagination 结构。
|
||
* 在当前页订单上增补 item_snapshot(格式:商品名称1*数量|商品名称2*数量)。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Object} data.pagination 分页参数。
|
||
* @param {Object} data.where 查询条件。
|
||
* @param {Object} data.sort 排序参数。
|
||
* @return {Promise<Object>} 列表查询结果。
|
||
*/
|
||
async waveStrategyFallbackOrderList(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { pagination, where, sort } = requestData;
|
||
const normalizedPagination = this.normalizePagination(pagination || {});
|
||
const normalizedWhere = this.normalizeWaveStrategyFallbackOrderListWhere(where);
|
||
const listResult = await this.listByModule('waveStrategyFallbackOrder', {
|
||
...requestData,
|
||
pagination: normalizedPagination,
|
||
where: normalizedWhere,
|
||
sort,
|
||
});
|
||
const normalizedResult = this.isPlainObject(listResult) ? listResult : {};
|
||
const sourceList = Array.isArray(normalizedResult.list) ? normalizedResult.list : [];
|
||
const orderIds = sourceList
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0);
|
||
const warehouseId = Number(this.getWarehouseId() || 0);
|
||
const itemSnapshotMap = new Map();
|
||
|
||
if (orderIds.length > 0 && Number.isInteger(warehouseId) && warehouseId > 0) {
|
||
try {
|
||
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
|
||
const hasValidModel = orderItemsModel && typeof orderItemsModel.findAll === 'function';
|
||
const hasOpIn = Op && Object.prototype.hasOwnProperty.call(Op, 'in');
|
||
|
||
if (hasValidModel && hasOpIn) {
|
||
const orderItemRows = await orderItemsModel.findAll({
|
||
where: {
|
||
order_id: { [Op.in]: orderIds },
|
||
},
|
||
attributes: [ 'order_id', 'plan_qty', 'stock_id', 'item_code', 'item_name', 'item_snapshot' ],
|
||
raw: true,
|
||
});
|
||
|
||
const orderItemsMap = new Map();
|
||
for (const row of orderItemRows || []) {
|
||
const orderId = Number(row && row.order_id || 0);
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
continue;
|
||
}
|
||
|
||
if (!orderItemsMap.has(orderId)) {
|
||
orderItemsMap.set(orderId, []);
|
||
}
|
||
orderItemsMap.get(orderId).push(row);
|
||
}
|
||
|
||
for (const orderId of orderIds) {
|
||
const itemRows = orderItemsMap.get(orderId) || [];
|
||
const itemDetails = this.mergeOrderItemDetails(itemRows);
|
||
itemSnapshotMap.set(orderId, this.buildOrderItemSnapshot(itemDetails));
|
||
}
|
||
}
|
||
} catch (error) {
|
||
this.ctx.logger && this.ctx.logger.warn && this.ctx.logger.warn('[wave.waveStrategyFallbackOrderList] 回填 item_snapshot 失败,已降级为空字符串', {
|
||
warehouseId,
|
||
orderCount: orderIds.length,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
});
|
||
}
|
||
}
|
||
|
||
const list = sourceList.map(item => {
|
||
const orderId = Number(item && item.id || 0);
|
||
return this.buildWaveStrategyFallbackOrderListItem(item, itemSnapshotMap.get(orderId) || '');
|
||
});
|
||
|
||
return this.success('ok', {
|
||
...normalizedResult,
|
||
list,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 波次列表查询。
|
||
*
|
||
* 默认查询状态为 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);
|
||
}
|
||
|
||
/**
|
||
* 提交波次策略快速扫描异步任务。
|
||
*
|
||
* 同一仓库同一时刻仅允许一个任务运行,若命中运行中任务则直接返回已有 task_id。
|
||
*
|
||
* @return {Promise<Object>} 任务受理结果。
|
||
*/
|
||
async waveStrategyQuickScan() {
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const warehouseId = contextWarehouseId;
|
||
const runningTask = await this.getWaveStrategyQuickScanWarehouseLock(warehouseId);
|
||
if (runningTask && runningTask.task_id) {
|
||
const existingTaskId = String(runningTask.task_id || '').trim();
|
||
const existingProgress = await this.getWaveStrategyQuickScanTaskProgress(existingTaskId);
|
||
const existingState = String(existingProgress && existingProgress.state || runningTask.state || 'running').trim() || 'running';
|
||
|
||
if (![ 'success', 'failed' ].includes(existingState)) {
|
||
return this.success('ok', {
|
||
status: 'success',
|
||
task_id: existingTaskId,
|
||
warehouse_id: warehouseId,
|
||
state: existingState,
|
||
message: 'Quick scan task is already running. Check progress with order.wave.waveStrategyQuickScanTaskProgress',
|
||
accepted_at: runningTask.accepted_at || existingProgress && existingProgress.accepted_at || new Date().toISOString(),
|
||
});
|
||
}
|
||
|
||
await this.clearWaveStrategyQuickScanWarehouseLock(warehouseId, existingTaskId);
|
||
}
|
||
|
||
const taskId = this.generateWaveStrategyQuickScanTaskId(warehouseId);
|
||
const acceptedAt = new Date().toISOString();
|
||
|
||
await this.setWaveStrategyQuickScanTaskProgress(taskId, 'submitted', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: 0,
|
||
processed_order_count: 0,
|
||
matched_order_count: 0,
|
||
unmatched_order_count: 0,
|
||
progress_percent: 0,
|
||
submitted_at: Date.now(),
|
||
accepted_at: acceptedAt,
|
||
start_time: null,
|
||
end_time: null,
|
||
error: '',
|
||
error_code: '',
|
||
result: null,
|
||
});
|
||
|
||
await this.setWaveStrategyQuickScanWarehouseLock(warehouseId, taskId, {
|
||
state: 'submitted',
|
||
accepted_at: acceptedAt,
|
||
});
|
||
|
||
setImmediate(() => {
|
||
this.runWaveStrategyQuickScanTask({
|
||
taskId,
|
||
warehouseId,
|
||
}).catch(error => {
|
||
this.ctx.logger.error('[wave.waveStrategyQuickScan] 后台任务异常', {
|
||
taskId,
|
||
warehouseId,
|
||
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,
|
||
state: 'submitted',
|
||
message: 'Quick scan task submitted. Check progress with order.wave.waveStrategyQuickScanTaskProgress',
|
||
accepted_at: acceptedAt,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 查询波次策略快速扫描任务进度。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {string} data.task_id 任务ID(下划线写法)。
|
||
* @param {string} data.taskId 任务ID(驼峰写法)。
|
||
* @return {Promise<Object>} 任务进度信息。
|
||
*/
|
||
async waveStrategyQuickScanTaskProgress(data = {}) {
|
||
const taskId = this.normalizeWaveStrategyQuickScanTaskId(data);
|
||
if (!taskId) {
|
||
return this.fail('task_id 参数不能为空', 400);
|
||
}
|
||
|
||
const cachedProgress = await this.getWaveStrategyQuickScanTaskProgress(taskId);
|
||
if (!cachedProgress) {
|
||
return this.success('ok', {
|
||
task_id: taskId,
|
||
state: 'not_found',
|
||
});
|
||
}
|
||
|
||
return this.success('ok', {
|
||
task_id: taskId,
|
||
state: String(cachedProgress.state || 'submitted').trim() || 'submitted',
|
||
warehouse_id: Number(cachedProgress.warehouse_id || 0),
|
||
total_order_count: Number(cachedProgress.total_order_count || 0),
|
||
processed_order_count: Number(cachedProgress.processed_order_count || 0),
|
||
matched_order_count: Number(cachedProgress.matched_order_count || 0),
|
||
unmatched_order_count: Number(cachedProgress.unmatched_order_count || 0),
|
||
progress_percent: Number(cachedProgress.progress_percent || 0),
|
||
submitted_at: cachedProgress.submitted_at || null,
|
||
start_time: cachedProgress.start_time || null,
|
||
end_time: cachedProgress.end_time || null,
|
||
error_message: String(cachedProgress.error || '').trim(),
|
||
error_code: String(cachedProgress.error_code || '').trim(),
|
||
duration_ms: Number(cachedProgress.duration_ms || 0),
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 执行波次策略快速扫描后台任务。
|
||
*
|
||
* 扫描范围:当前仓库 + step != 0 + wave_id = 0 + wave_strategy_version != 当前策略版本。
|
||
*
|
||
* @param {Object} [params={}] 任务参数。
|
||
* @param {string} params.taskId 任务ID。
|
||
* @param {number|string} [params.warehouseId] 仓库ID。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async runWaveStrategyQuickScanTask(params = {}) {
|
||
const normalizedTaskId = String(params && params.taskId || '').trim();
|
||
if (!normalizedTaskId) {
|
||
throw new Error('taskId 不能为空');
|
||
}
|
||
|
||
const cachedTask = await this.getWaveStrategyQuickScanTaskProgress(normalizedTaskId);
|
||
const warehouseId = Number(
|
||
cachedTask && cachedTask.warehouse_id !== undefined
|
||
? cachedTask.warehouse_id
|
||
: params && params.warehouseId
|
||
);
|
||
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'failed', {
|
||
end_time: Date.now(),
|
||
error: 'warehouse_id 参数不合法',
|
||
error_code: 'INVALID_WAREHOUSE_ID',
|
||
});
|
||
return;
|
||
}
|
||
|
||
const startTime = Date.now();
|
||
await this.setWaveStrategyQuickScanWarehouseLock(warehouseId, normalizedTaskId, {
|
||
state: 'running',
|
||
});
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'running', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: 0,
|
||
processed_order_count: 0,
|
||
matched_order_count: 0,
|
||
unmatched_order_count: 0,
|
||
progress_percent: 0,
|
||
start_time: startTime,
|
||
end_time: null,
|
||
error: '',
|
||
error_code: '',
|
||
result: null,
|
||
});
|
||
|
||
try {
|
||
const subjectConfig = await this.getWarehouseSubjectConfig(warehouseId);
|
||
const strategyVersion = this.normalizeWaveStrategyQuickScanVersion(
|
||
this.getWarehouseSubjectConfigValue(subjectConfig, 'wave_strategy_version')
|
||
);
|
||
|
||
const strategyModel = this.ctx.model && (
|
||
this.ctx.model.wms_wave_strategy
|
||
|| this.ctx.model.PickingStrategy
|
||
|| this.ctx.model.WmsWaveStrategy
|
||
);
|
||
if (!strategyModel || typeof strategyModel.findAll !== 'function') {
|
||
throw new Error('波次策略模型不可用');
|
||
}
|
||
|
||
const strategyRows = await strategyModel.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
status: 1,
|
||
},
|
||
order: [[ 'id', 'ASC' ]],
|
||
raw: true,
|
||
});
|
||
const strategyList = this.normalizeWaveStrategyQuickScanList(strategyRows);
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
attributes: [
|
||
'id',
|
||
'store_id',
|
||
'items_count',
|
||
'items_total',
|
||
'items_hash',
|
||
'items',
|
||
'logistics_code',
|
||
'sys_logistics_code',
|
||
'logistics_name',
|
||
'province',
|
||
'sys_platform_code',
|
||
'source_platform_code',
|
||
],
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
step: { [Op.ne]: 0 },
|
||
wave_id: 0,
|
||
[Op.or]: [
|
||
{ wave_strategy_version: { [Op.ne]: strategyVersion } },
|
||
{ wave_strategy_version: { [Op.is]: null } },
|
||
],
|
||
},
|
||
raw: true,
|
||
});
|
||
|
||
const normalizedOrders = Array.isArray(orderRows) ? orderRows : [];
|
||
const totalOrderCount = normalizedOrders.length;
|
||
if (totalOrderCount === 0) {
|
||
const durationMs = Date.now() - startTime;
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'success', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: 0,
|
||
processed_order_count: 0,
|
||
matched_order_count: 0,
|
||
unmatched_order_count: 0,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
strategy_version: strategyVersion,
|
||
duration_ms: durationMs,
|
||
message: '未找到需要扫描的订单',
|
||
},
|
||
});
|
||
return;
|
||
}
|
||
|
||
const structureStoreSetMap = new Map();
|
||
|
||
for (const order of normalizedOrders) {
|
||
const structureKey = this.getWaveStrategyQuickScanStructureKey(order);
|
||
if (!structureKey) {
|
||
continue;
|
||
}
|
||
|
||
const storeId = String(order && order.store_id || '').trim();
|
||
if (!structureStoreSetMap.has(structureKey)) {
|
||
structureStoreSetMap.set(structureKey, new Set());
|
||
}
|
||
if (storeId) {
|
||
structureStoreSetMap.get(structureKey).add(storeId);
|
||
}
|
||
}
|
||
|
||
const matchedOrderIds = [];
|
||
const unmatchedOrderIds = [];
|
||
let processedOrderCount = 0;
|
||
|
||
for (const order of normalizedOrders) {
|
||
const matched = this.isWaveStrategyQuickScanOrderMatched(order, strategyList, {
|
||
structureStoreSetMap,
|
||
});
|
||
|
||
const orderId = Number(order && order.id || 0);
|
||
if (Number.isInteger(orderId) && orderId > 0) {
|
||
if (matched) {
|
||
matchedOrderIds.push(orderId);
|
||
} else {
|
||
unmatchedOrderIds.push(orderId);
|
||
}
|
||
}
|
||
|
||
processedOrderCount += 1;
|
||
if (processedOrderCount % 200 === 0 || processedOrderCount === totalOrderCount) {
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'running', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: totalOrderCount,
|
||
processed_order_count: processedOrderCount,
|
||
matched_order_count: matchedOrderIds.length,
|
||
unmatched_order_count: unmatchedOrderIds.length,
|
||
progress_percent: Math.min(99, Math.round((processedOrderCount / totalOrderCount) * 100)),
|
||
});
|
||
}
|
||
}
|
||
|
||
await this.batchUpdateWaveStrategyQuickScanOrders(orderModel, matchedOrderIds, {
|
||
wave_strategy_version: strategyVersion,
|
||
wave_scan_result: 1,
|
||
});
|
||
await this.batchUpdateWaveStrategyQuickScanOrders(orderModel, unmatchedOrderIds, {
|
||
wave_strategy_version: strategyVersion,
|
||
wave_scan_result: 2,
|
||
});
|
||
|
||
const durationMs = Date.now() - startTime;
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'success', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: totalOrderCount,
|
||
processed_order_count: totalOrderCount,
|
||
matched_order_count: matchedOrderIds.length,
|
||
unmatched_order_count: unmatchedOrderIds.length,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
strategy_version: strategyVersion,
|
||
matched_order_count: matchedOrderIds.length,
|
||
unmatched_order_count: unmatchedOrderIds.length,
|
||
duration_ms: durationMs,
|
||
message: '波次策略快速扫描完成',
|
||
},
|
||
});
|
||
} catch (error) {
|
||
await this.setWaveStrategyQuickScanTaskProgress(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_STRATEGY_QUICK_SCAN_FAILED',
|
||
});
|
||
} finally {
|
||
await this.clearWaveStrategyQuickScanWarehouseLock(warehouseId, normalizedTaskId);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量更新快速扫描结果。
|
||
*
|
||
* @param {Object} orderModel 订单模型。
|
||
* @param {Array<number>} orderIds 订单ID数组。
|
||
* @param {Object} updatePayload 更新字段。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async batchUpdateWaveStrategyQuickScanOrders(orderModel, orderIds = [], updatePayload = {}) {
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (normalizedOrderIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
for (let i = 0; i < normalizedOrderIds.length; i += 500) {
|
||
const chunkIds = normalizedOrderIds.slice(i, i + 500);
|
||
if (chunkIds.length === 0) {
|
||
continue;
|
||
}
|
||
|
||
await orderModel.update(updatePayload, {
|
||
where: {
|
||
id: {
|
||
[Op.in]: chunkIds,
|
||
},
|
||
},
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成波次策略快速扫描任务ID。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @return {string} 任务ID。
|
||
*/
|
||
generateWaveStrategyQuickScanTaskId(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_quick_scan_${safeWarehouseId}_${timestamp}_${randomPart}`;
|
||
}
|
||
|
||
/**
|
||
* 归一化波次策略快速扫描任务ID。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @return {string} 归一化后的任务ID。
|
||
*/
|
||
normalizeWaveStrategyQuickScanTaskId(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
|
||
}
|
||
|
||
/**
|
||
* 获取波次策略快速扫描任务缓存键。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @return {string} 缓存键。
|
||
*/
|
||
getWaveStrategyQuickScanTaskCacheKey(taskId = '') {
|
||
const normalizedTaskId = String(taskId || '').trim();
|
||
if (!normalizedTaskId) {
|
||
return '';
|
||
}
|
||
|
||
return `${WAVE_STRATEGY_QUICK_SCAN_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
|
||
}
|
||
|
||
/**
|
||
* 写入波次策略快速扫描任务进度缓存。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @param {string} state 任务状态。
|
||
* @param {Object} payload 进度数据。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async setWaveStrategyQuickScanTaskProgress(taskId = '', state = 'submitted', payload = {}) {
|
||
const cacheKey = this.getWaveStrategyQuickScanTaskCacheKey(taskId);
|
||
if (!cacheKey) {
|
||
return;
|
||
}
|
||
|
||
const safePayload = this.isPlainObject(payload) ? payload : {};
|
||
const mergedPayload = {
|
||
...(await this.getWaveStrategyQuickScanTaskProgress(taskId) || {}),
|
||
...safePayload,
|
||
task_id: String(taskId || '').trim(),
|
||
state: String(state || '').trim() || 'submitted',
|
||
update_time: Date.now(),
|
||
};
|
||
|
||
try {
|
||
await this.app.setCacheAsync(cacheKey, mergedPayload, WAVE_STRATEGY_QUICK_SCAN_TASK_CACHE_TTL_SECONDS);
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.waveStrategyQuickScan] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 读取波次策略快速扫描任务进度缓存。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @return {Promise<Object|null>} 缓存对象。
|
||
*/
|
||
async getWaveStrategyQuickScanTaskProgress(taskId = '') {
|
||
const cacheKey = this.getWaveStrategyQuickScanTaskCacheKey(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.waveStrategyQuickScan] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取波次策略快速扫描仓库锁缓存键。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @return {string} 缓存键。
|
||
*/
|
||
getWaveStrategyQuickScanWarehouseLockCacheKey(warehouseId = 0) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return '';
|
||
}
|
||
|
||
return `${WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_CACHE_KEY_PREFIX}${normalizedWarehouseId}`;
|
||
}
|
||
|
||
/**
|
||
* 写入波次策略快速扫描仓库锁。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {string} taskId 任务ID。
|
||
* @param {Object} [extra={}] 附加字段。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async setWaveStrategyQuickScanWarehouseLock(warehouseId = 0, taskId = '', extra = {}) {
|
||
const cacheKey = this.getWaveStrategyQuickScanWarehouseLockCacheKey(warehouseId);
|
||
const normalizedTaskId = String(taskId || '').trim();
|
||
if (!cacheKey || !normalizedTaskId) {
|
||
return;
|
||
}
|
||
|
||
const extraPayload = this.isPlainObject(extra) ? extra : {};
|
||
const lockPayload = {
|
||
warehouse_id: Number(warehouseId || 0),
|
||
task_id: normalizedTaskId,
|
||
state: String(extraPayload.state || 'running').trim() || 'running',
|
||
accepted_at: extraPayload.accepted_at || undefined,
|
||
update_time: Date.now(),
|
||
};
|
||
|
||
try {
|
||
await this.app.setCacheAsync(cacheKey, lockPayload, WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_TTL_SECONDS);
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.waveStrategyQuickScan] 写入仓库锁缓存失败: %s', error && error.message ? error.message : error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 读取波次策略快速扫描仓库锁。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @return {Promise<Object|null>} 锁信息。
|
||
*/
|
||
async getWaveStrategyQuickScanWarehouseLock(warehouseId = 0) {
|
||
const cacheKey = this.getWaveStrategyQuickScanWarehouseLockCacheKey(warehouseId);
|
||
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.waveStrategyQuickScan] 读取仓库锁缓存失败: %s', error && error.message ? error.message : error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理波次策略快速扫描仓库锁。
|
||
*
|
||
* 仅当当前锁 owner 与传入 taskId 一致时才删除,防止误删并发任务锁。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {string} [taskId=''] 当前任务ID。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async clearWaveStrategyQuickScanWarehouseLock(warehouseId = 0, taskId = '') {
|
||
const cacheKey = this.getWaveStrategyQuickScanWarehouseLockCacheKey(warehouseId);
|
||
if (!cacheKey) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const cachedLock = await this.app.getCacheAsync(cacheKey);
|
||
const lockTaskId = String(cachedLock && cachedLock.task_id || '').trim();
|
||
const currentTaskId = String(taskId || '').trim();
|
||
if (lockTaskId && currentTaskId && lockTaskId !== currentTaskId) {
|
||
return;
|
||
}
|
||
|
||
if (typeof this.app.delCacheAsync === 'function') {
|
||
await this.app.delCacheAsync(cacheKey);
|
||
} else {
|
||
await this.app.setCacheAsync(cacheKey, null, 0);
|
||
}
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.waveStrategyQuickScan] 清理仓库锁缓存失败: %s', error && error.message ? error.message : error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 将仓库策略版本号归一化为非负整数。
|
||
*
|
||
* @param {*} value 原始版本号。
|
||
* @return {number} 归一化版本号。
|
||
*/
|
||
normalizeWaveStrategyQuickScanVersion(value) {
|
||
const versionNumber = Number(value);
|
||
if (!Number.isFinite(versionNumber)) {
|
||
return 0;
|
||
}
|
||
|
||
const safeVersion = Math.floor(versionNumber);
|
||
return Number.isInteger(safeVersion) && safeVersion >= 0 ? safeVersion : 0;
|
||
}
|
||
|
||
/**
|
||
* 归一化快速扫描策略列表。
|
||
*
|
||
* @param {*} strategyRows 策略行数组。
|
||
* @return {Array<Object>} 标准化策略列表。
|
||
*/
|
||
normalizeWaveStrategyQuickScanList(strategyRows) {
|
||
const list = Array.isArray(strategyRows) ? strategyRows : [];
|
||
return list.map(row => {
|
||
const normalizedRow = this.isPlainObject(row) ? row : {};
|
||
return {
|
||
order_min_sku: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.order_min_sku),
|
||
order_max_sku: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.order_max_sku),
|
||
order_min_qty: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.order_min_qty),
|
||
order_max_qty: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.order_max_qty),
|
||
min_same_structure: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.min_same_structure),
|
||
max_same_structure: this.normalizeWaveStrategyQuickScanNumberOrNull(normalizedRow.max_same_structure),
|
||
allowed_owners: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_owners),
|
||
allowed_expresses: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_expresses),
|
||
allowed_provinces: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_provinces),
|
||
allowed_platforms: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_platforms),
|
||
require_same_express: this.normalizeWaveStrategyQuickScanBoolean(normalizedRow.require_same_express, false),
|
||
allow_cross_owner: this.normalizeWaveStrategyQuickScanBoolean(normalizedRow.allow_cross_owner, true),
|
||
};
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 归一化为可为空的数值。
|
||
*
|
||
* @param {*} value 原始数值。
|
||
* @return {number|null} 数值或 null。
|
||
*/
|
||
normalizeWaveStrategyQuickScanNumberOrNull(value) {
|
||
if (value === undefined || value === null || value === '') {
|
||
return null;
|
||
}
|
||
|
||
const normalizedValue = Number(value);
|
||
if (!Number.isFinite(normalizedValue)) {
|
||
return null;
|
||
}
|
||
|
||
return normalizedValue;
|
||
}
|
||
|
||
/**
|
||
* 归一化快速扫描布尔值。
|
||
*
|
||
* @param {*} value 原始值。
|
||
* @param {boolean} [defaultValue=false] 默认值。
|
||
* @return {boolean} 布尔值。
|
||
*/
|
||
normalizeWaveStrategyQuickScanBoolean(value, defaultValue = false) {
|
||
if (typeof value === 'boolean') {
|
||
return value;
|
||
}
|
||
|
||
if (value === undefined || value === null || value === '') {
|
||
return defaultValue;
|
||
}
|
||
|
||
const normalizedValue = String(value).trim().toLowerCase();
|
||
if ([ '1', 'true', 'yes', 'y', 'on' ].includes(normalizedValue)) {
|
||
return true;
|
||
}
|
||
if ([ '0', 'false', 'no', 'n', 'off' ].includes(normalizedValue)) {
|
||
return false;
|
||
}
|
||
|
||
return defaultValue;
|
||
}
|
||
|
||
/**
|
||
* 归一化快速扫描字符串数组。
|
||
*
|
||
* 支持数组、JSON 字符串、逗号分隔字符串。
|
||
*
|
||
* @param {*} value 原始值。
|
||
* @return {Array<string>} 归一化字符串数组(小写去重)。
|
||
*/
|
||
normalizeWaveStrategyQuickScanStringList(value) {
|
||
let rawList = [];
|
||
|
||
if (Array.isArray(value)) {
|
||
rawList = value;
|
||
} else if (typeof value === 'string') {
|
||
const trimmed = value.trim();
|
||
if (!trimmed) {
|
||
rawList = [];
|
||
} else if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
|
||
try {
|
||
const parsed = JSON.parse(trimmed);
|
||
rawList = Array.isArray(parsed) ? parsed : [];
|
||
} catch (error) {
|
||
rawList = trimmed.split(/[,,;|\n\r]+/);
|
||
}
|
||
} else {
|
||
rawList = trimmed.split(/[,,;|\n\r]+/);
|
||
}
|
||
} else if (value !== undefined && value !== null) {
|
||
rawList = [ value ];
|
||
}
|
||
|
||
return [ ...new Set(rawList
|
||
.map(item => String(item || '').trim().toLowerCase())
|
||
.filter(Boolean)) ];
|
||
}
|
||
|
||
/**
|
||
* 计算订单结构 key(items_hash 优先,其次 items)。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @return {string} 结构 key。
|
||
*/
|
||
getWaveStrategyQuickScanStructureKey(order = {}) {
|
||
const itemsHash = String(order && order.items_hash || '').trim();
|
||
if (itemsHash) {
|
||
return itemsHash;
|
||
}
|
||
|
||
return String(order && order.items || '').trim();
|
||
}
|
||
|
||
/**
|
||
* 计算订单快递 key。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @return {string} 快递 key。
|
||
*/
|
||
getWaveStrategyQuickScanExpressKey(order = {}) {
|
||
const sysLogisticsCode = String(order && order.sys_logistics_code || '').trim();
|
||
if (sysLogisticsCode) {
|
||
return sysLogisticsCode;
|
||
}
|
||
|
||
const logisticsCode = String(order && order.logistics_code || '').trim();
|
||
if (logisticsCode) {
|
||
return logisticsCode;
|
||
}
|
||
|
||
return String(order && order.logistics_name || '').trim();
|
||
}
|
||
|
||
/**
|
||
* 判断订单是否命中任一快速扫描策略。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @param {Array<Object>} strategyList 策略列表。
|
||
* @param {Object} context 统计上下文。
|
||
* @return {boolean} 是否命中。
|
||
*/
|
||
isWaveStrategyQuickScanOrderMatched(order = {}, strategyList = [], context = {}) {
|
||
const list = Array.isArray(strategyList) ? strategyList : [];
|
||
if (list.length === 0) {
|
||
return false;
|
||
}
|
||
|
||
for (const strategy of list) {
|
||
if (this.isWaveStrategyQuickScanOrderMatchedSingleStrategy(order, strategy, context)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 判断订单是否命中单条快速扫描策略。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @param {Object} strategy 策略配置。
|
||
* @param {Object} context 统计上下文。
|
||
* @return {boolean} 是否命中。
|
||
*/
|
||
isWaveStrategyQuickScanOrderMatchedSingleStrategy(order = {}, strategy = {}, context = {}) {
|
||
const normalizedOrder = this.isPlainObject(order) ? order : {};
|
||
const normalizedStrategy = this.isPlainObject(strategy) ? strategy : {};
|
||
const structureStoreSetMap = context && context.structureStoreSetMap instanceof Map ? context.structureStoreSetMap : new Map();
|
||
|
||
const structureKey = this.getWaveStrategyQuickScanStructureKey(normalizedOrder);
|
||
if (!structureKey) {
|
||
return false;
|
||
}
|
||
|
||
if (normalizedStrategy.allow_cross_owner === false) {
|
||
const ownerSet = structureStoreSetMap.get(structureKey);
|
||
if (ownerSet instanceof Set && ownerSet.size > 1) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
const itemsCount = Number(normalizedOrder.items_count || 0);
|
||
const itemsTotal = Number(normalizedOrder.items_total || 0);
|
||
|
||
if (!this.isWaveStrategyQuickScanValueInRange(itemsCount, normalizedStrategy.order_min_sku, normalizedStrategy.order_max_sku)) {
|
||
return false;
|
||
}
|
||
if (!this.isWaveStrategyQuickScanValueInRange(itemsTotal, normalizedStrategy.order_min_qty, normalizedStrategy.order_max_qty)) {
|
||
return false;
|
||
}
|
||
|
||
const storeId = String(normalizedOrder.store_id || '').trim().toLowerCase();
|
||
if (normalizedStrategy.allowed_owners.length > 0 && !normalizedStrategy.allowed_owners.includes(storeId)) {
|
||
return false;
|
||
}
|
||
|
||
const expressCandidates = [
|
||
String(normalizedOrder.sys_logistics_code || '').trim().toLowerCase(),
|
||
String(normalizedOrder.logistics_code || '').trim().toLowerCase(),
|
||
String(normalizedOrder.logistics_name || '').trim().toLowerCase(),
|
||
].filter(Boolean);
|
||
if (normalizedStrategy.allowed_expresses.length > 0) {
|
||
const hitExpress = expressCandidates.some(code => normalizedStrategy.allowed_expresses.includes(code));
|
||
if (!hitExpress) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
const province = String(normalizedOrder.province || '').trim().toLowerCase();
|
||
if (normalizedStrategy.allowed_provinces.length > 0 && !normalizedStrategy.allowed_provinces.includes(province)) {
|
||
return false;
|
||
}
|
||
|
||
const platformCandidates = [
|
||
String(normalizedOrder.sys_platform_code || '').trim().toLowerCase(),
|
||
String(normalizedOrder.source_platform_code || '').trim().toLowerCase(),
|
||
].filter(Boolean);
|
||
if (normalizedStrategy.allowed_platforms.length > 0) {
|
||
const hitPlatform = platformCandidates.some(code => normalizedStrategy.allowed_platforms.includes(code));
|
||
if (!hitPlatform) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 判断值是否命中区间。
|
||
*
|
||
* @param {number} value 待判断值。
|
||
* @param {number|null} min 最小值。
|
||
* @param {number|null} max 最大值。
|
||
* @return {boolean} 是否命中。
|
||
*/
|
||
isWaveStrategyQuickScanValueInRange(value, min, max) {
|
||
const normalizedValue = Number(value);
|
||
if (!Number.isFinite(normalizedValue)) {
|
||
return false;
|
||
}
|
||
|
||
const hasMin = Number.isFinite(Number(min));
|
||
const hasMax = Number.isFinite(Number(max));
|
||
if (hasMin && normalizedValue < Number(min)) {
|
||
return false;
|
||
}
|
||
if (hasMax && normalizedValue > Number(max)) {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 过滤 singleFetchByIds 中属于团购候选结构的订单。
|
||
*
|
||
* 规则:同结构(items_hash/items)待处理订单数达到最小团购阈值时,视为团购候选。
|
||
* 为避免误抓,singleFetchByIds 默认排除这些订单,仅允许显式团购入口处理。
|
||
*
|
||
* @param {Object} orderModel 订单模型。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {Array<Object>} orderRows 待过滤订单行。
|
||
* @return {Promise<number[]>} 需排除的订单ID集合。
|
||
*/
|
||
async resolveGroupCandidateOrderIdsForSingleFetch(orderModel, warehouseId, orderRows = []) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedRows = Array.isArray(orderRows)
|
||
? orderRows.filter(row => Number.isInteger(Number(row && row.id || 0)) && Number(row && row.id || 0) > 0)
|
||
: [];
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0 || normalizedRows.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const minGroupOrderFetchQuantity = await this.getMinGroupOrderFetchQuantity(normalizedWarehouseId);
|
||
if (!Number.isInteger(Number(minGroupOrderFetchQuantity)) || Number(minGroupOrderFetchQuantity) <= 1) {
|
||
return [];
|
||
}
|
||
|
||
const itemHashValues = [ ...new Set(normalizedRows
|
||
.map(row => String(row && row.items_hash || '').trim())
|
||
.filter(Boolean)) ];
|
||
const itemValues = [ ...new Set(normalizedRows
|
||
.map(row => String(row && row.items || '').trim())
|
||
.filter(Boolean)) ];
|
||
if (itemHashValues.length === 0 && itemValues.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const candidateWhereList = [];
|
||
if (itemHashValues.length > 0) {
|
||
candidateWhereList.push({
|
||
items_hash: { [Op.in]: itemHashValues },
|
||
});
|
||
}
|
||
if (itemValues.length > 0) {
|
||
candidateWhereList.push({
|
||
items: { [Op.in]: itemValues },
|
||
});
|
||
}
|
||
if (candidateWhereList.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const candidateRows = await orderModel.findAll({
|
||
attributes: [ 'id', 'items_hash', 'items', 'logistics_name' ],
|
||
where: {
|
||
wave_id: 0,
|
||
step: { [Op.in]: [ 1, 2, 3 ] },
|
||
status: { [Op.ne]: 'cancel' },
|
||
outbound_status: { [Op.ne]: 'padding' },
|
||
[Op.or]: candidateWhereList,
|
||
},
|
||
raw: true,
|
||
});
|
||
|
||
const buildItemKey = row => {
|
||
const itemHash = String(row && row.items_hash || '').trim();
|
||
const itemText = String(row && row.items || '').trim();
|
||
if (itemHash) {
|
||
return `items_hash:${itemHash}`;
|
||
}
|
||
if (itemText) {
|
||
return `items:${itemText}`;
|
||
}
|
||
return '';
|
||
};
|
||
|
||
const itemCountMap = new Map();
|
||
for (const row of Array.isArray(candidateRows) ? candidateRows : []) {
|
||
const itemKey = buildItemKey(row);
|
||
if (!itemKey) {
|
||
continue;
|
||
}
|
||
itemCountMap.set(itemKey, Number(itemCountMap.get(itemKey) || 0) + 1);
|
||
}
|
||
|
||
const excludedOrderIds = [];
|
||
const normalizedThreshold = Number(minGroupOrderFetchQuantity);
|
||
for (const row of normalizedRows) {
|
||
const orderId = Number(row && row.id || 0);
|
||
const itemKey = buildItemKey(row);
|
||
if (!itemKey) {
|
||
continue;
|
||
}
|
||
|
||
const itemGroupCount = Number(itemCountMap.get(itemKey) || 0);
|
||
if (itemGroupCount >= normalizedThreshold) {
|
||
excludedOrderIds.push(orderId);
|
||
}
|
||
}
|
||
|
||
return [ ...new Set(excludedOrderIds) ].sort((a, b) => a - b);
|
||
}
|
||
|
||
/**
|
||
* 按订单ID集合抓取到一个散单波次。
|
||
*
|
||
* 规则:
|
||
* 1. 仅处理当前仓库上下文订单;
|
||
* 2. 传入 ids 中已存在波次(wave_id>0)的订单会被排除;
|
||
* 3. 不区分快递,所有可抓取订单统一写入同一个新波次;
|
||
* 4. 除已在波次中的订单外,其余传入且存在的订单均可抓取;
|
||
* 5. 成功抓取后批量写入订单操作日志。
|
||
*
|
||
* @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集合别名。
|
||
* @return {Promise<Object>} 抓取结果。
|
||
*/
|
||
async singleFetchByIds(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
|
||
);
|
||
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 orderRows = await orderModel.findAll({
|
||
attributes: [ 'id', 'wave_id', 'wave_no', 'step', 'status', 'outbound_status', 'items_hash', 'items', 'logistics_name' ],
|
||
where: {
|
||
id: { [Op.in]: normalizedIds },
|
||
},
|
||
raw: true,
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
});
|
||
|
||
const normalizedOrderRows = Array.isArray(orderRows) ? orderRows : [];
|
||
const foundOrderIds = [ ...new Set(normalizedOrderRows
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
const existingWaveRows = normalizedOrderRows
|
||
.filter(row => Number(row && row.wave_id || 0) > 0);
|
||
const excludedExistingWaveOrderIds = [ ...new Set(existingWaveRows
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
|
||
const fetchableRows = normalizedOrderRows.filter(row => {
|
||
const orderId = Number(row && row.id || 0);
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
return false;
|
||
}
|
||
|
||
if (waveId > 0) {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
});
|
||
|
||
const fetchableOrderIds = [ ...new Set(fetchableRows
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
const notFoundOrderIds = normalizedIds.filter(id => !foundOrderIds.includes(id));
|
||
const skippedOrderIds = normalizedIds.filter(id => !fetchableOrderIds.includes(id));
|
||
|
||
if (fetchableOrderIds.length === 0) {
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
fetched_order_ids: [],
|
||
fetched_order_count: 0,
|
||
excluded_existing_wave_order_ids: excludedExistingWaveOrderIds,
|
||
skipped_order_ids: skippedOrderIds,
|
||
not_found_order_ids: notFoundOrderIds,
|
||
});
|
||
}
|
||
|
||
const singleFetchByIdsWavePrefix = await this.getSingleFetchByIdsWavePrefix(warehouseId);
|
||
|
||
const { waveId, waveNo } = await this.createWaveBatchReady({
|
||
warehouseId,
|
||
totalOrders: fetchableOrderIds.length,
|
||
itemDetailMachine: `manual_single_ids_${Date.now()}`,
|
||
itemPartType: 'manual_ids',
|
||
itemPart: `ids_${fetchableOrderIds.length}`,
|
||
waveType: 2,
|
||
distinguishExpress: false,
|
||
logisticsName: '',
|
||
itemSnapshotKey: 'manual_single_ids',
|
||
wavePrefix: singleFetchByIdsWavePrefix,
|
||
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 orderModel.update({
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
order_flag: orderFlagExpression,
|
||
}, {
|
||
where: {
|
||
id: { [Op.in]: fetchableOrderIds },
|
||
wave_id: 0,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const grabbedRows = await orderModel.findAll({
|
||
where: {
|
||
id: { [Op.in]: fetchableOrderIds },
|
||
wave_id: waveId,
|
||
},
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
const grabbedOrderIds = [ ...new Set((Array.isArray(grabbedRows) ? grabbedRows : [])
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
|
||
if (grabbedOrderIds.length <= 0) {
|
||
await this.ctx.model.query(`
|
||
DELETE FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
`, {
|
||
replacements: { waveId },
|
||
transaction,
|
||
});
|
||
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
fetched_order_ids: [],
|
||
fetched_order_count: 0,
|
||
excluded_existing_wave_order_ids: excludedExistingWaveOrderIds,
|
||
skipped_order_ids: skippedOrderIds,
|
||
not_found_order_ids: notFoundOrderIds,
|
||
});
|
||
}
|
||
|
||
if (grabbedOrderIds.length !== fetchableOrderIds.length) {
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_batch
|
||
SET total_orders = :totalOrders,
|
||
update_time = NOW()
|
||
WHERE wave_id = :waveId
|
||
`, {
|
||
replacements: {
|
||
waveId,
|
||
totalOrders: grabbedOrderIds.length,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
await this.rebuildOrderWaveIndex({
|
||
warehouseId,
|
||
waveId,
|
||
orderIds: grabbedOrderIds,
|
||
orderModel,
|
||
transaction,
|
||
});
|
||
|
||
await transaction.commit();
|
||
|
||
await this.batchCreateOrderOperationLogs(grabbedOrderIds.map(orderId => ({
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_ASSIGN',
|
||
message: `订单被分配到波次 ${waveNo}`,
|
||
})), {
|
||
warehouseId,
|
||
scene: 'singleFetchByIds',
|
||
});
|
||
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
fetched_order_ids: grabbedOrderIds,
|
||
fetched_order_count: grabbedOrderIds.length,
|
||
excluded_existing_wave_order_ids: excludedExistingWaveOrderIds,
|
||
skipped_order_ids: skippedOrderIds,
|
||
not_found_order_ids: notFoundOrderIds,
|
||
});
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量将订单从波次中移出。
|
||
*
|
||
* 仅处理当前仓库待处理订单中 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 remainingCountMap = await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: affectedWaveIds,
|
||
orderModel,
|
||
transaction,
|
||
});
|
||
|
||
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 affectedOrderIds = [ ...new Set((Array.isArray(affectedOrderRows) ? affectedOrderRows : [])
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
|
||
|
||
const orderUpdateResult = await orderModel.update({
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
}, {
|
||
where: {
|
||
wave_id: waveId,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
if (affectedOrderIds.length > 0) {
|
||
await this.deleteOrderWaveIndexByOrderIds({
|
||
warehouseId,
|
||
orderIds: affectedOrderIds,
|
||
transaction,
|
||
});
|
||
} else {
|
||
await this.deleteOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: [ 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 orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: updatableWaveIds,
|
||
orderModel,
|
||
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 orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: updatedWaveIds,
|
||
orderModel,
|
||
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;
|