13364 lines
481 KiB
JavaScript
13364 lines
481 KiB
JavaScript
'use strict';
|
||
|
||
const { Op } = require('sequelize');
|
||
const OrderBaseService = require('./base');
|
||
const runWaveStrategyQuickScanRunner = require('../../../lib/wave_strategy_quick_scan_runner');
|
||
|
||
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 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 * 5;
|
||
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 WAVE_STRATEGY_LIST_CACHE_KEY_PREFIX = 'wave:strategy-list:';
|
||
const WAVE_STRATEGY_LIST_CACHE_TTL_SECONDS = 60 * 30;
|
||
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',
|
||
});
|
||
const WAVE_STRATEGY_FALLBACK_EXCLUDED_REASON_LABELS = Object.freeze({
|
||
locked: '已锁定',
|
||
intercepted: '已拦截',
|
||
printed: '已打印',
|
||
no_match: '未匹配策略',
|
||
});
|
||
const BATCH_LIST_ASSIGNMENT_FILTER_SCHEMAS = Object.freeze({
|
||
storage: Object.freeze({
|
||
fieldName: 'storage_assignment_status',
|
||
enumMap: Object.freeze({
|
||
未分配: 'none',
|
||
部分分配: 'partial',
|
||
已分配: 'finished',
|
||
}),
|
||
caseInsensitive: false,
|
||
statsColumnPrefix: 'storage',
|
||
withErrorStatus: true,
|
||
}),
|
||
express: Object.freeze({
|
||
fieldName: 'express_assignment_status',
|
||
enumMap: Object.freeze({
|
||
unassigned: 'none',
|
||
partially_assigned: 'partial',
|
||
assigned: 'finished',
|
||
}),
|
||
caseInsensitive: true,
|
||
statsColumnPrefix: 'post',
|
||
withErrorStatus: true,
|
||
}),
|
||
print: Object.freeze({
|
||
fieldName: 'print_assignment_status',
|
||
enumMap: Object.freeze({
|
||
unprinted: 'none',
|
||
partially_printed: 'partial',
|
||
printed: 'finished',
|
||
}),
|
||
caseInsensitive: true,
|
||
statsColumnPrefix: 'print',
|
||
withErrorStatus: false,
|
||
}),
|
||
review: Object.freeze({
|
||
fieldName: 'review_assignment_status',
|
||
enumMap: Object.freeze({
|
||
unreviewed: 'none',
|
||
partially_reviewed: 'partial',
|
||
reviewed: 'finished',
|
||
}),
|
||
caseInsensitive: true,
|
||
statsColumnPrefix: 'review',
|
||
withErrorStatus: true,
|
||
}),
|
||
});
|
||
|
||
class WaveService extends OrderBaseService {
|
||
/**
|
||
* 初始化波次方法权限配置。
|
||
*
|
||
* @param {Egg.Context} ctx 请求上下文。
|
||
*/
|
||
constructor(ctx) {
|
||
super(ctx);
|
||
const _noNeedLogin = '';
|
||
const _noNeedRight = 'wavePickTaskCancelSelf,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
|
||
const _noNeedLog = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
|
||
const _noNeedAuth = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,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}`;
|
||
}
|
||
|
||
/**
|
||
* 获取当天前缀下的下一个波次序号(原子取号)。
|
||
*
|
||
* 基于序列表 wms_number_sequence 的单条 upsert 原子递增:
|
||
* INSERT ... VALUES (LAST_INSERT_ID(:seed + 1)) ON DUPLICATE KEY UPDATE
|
||
* current_seq = LAST_INSERT_ID(GREATEST(current_seq, :seed) + 1)
|
||
* 其中 :seed 为当日该前缀主表已有最大序号,保证与历史编号对齐;
|
||
* 同事务(同连接)内回读 LAST_INSERT_ID() 取回本次分配序号,并发下不再撞号。
|
||
*
|
||
* @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 prefixDatePartLength = normalizedPrefix.length + normalizedDatePart.length;
|
||
const bizType = `wave_no_${normalizedPrefix.slice(0, 20)}`;
|
||
|
||
// 历史对齐种子:当日该前缀主表已有最大序号(无则为 0)
|
||
const seedRows = await this.ctx.model.query(
|
||
`SELECT IFNULL(MAX(CAST(SUBSTRING(wave_no, :startPos) AS UNSIGNED)), 0) AS max_seq
|
||
FROM wms_wave_batch
|
||
WHERE wave_no LIKE :pattern`,
|
||
{
|
||
replacements: {
|
||
pattern,
|
||
startPos: prefixDatePartLength + 1,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
const seed = Number(seedRows && seedRows[0] && seedRows[0].max_seq || 0);
|
||
|
||
// 原子取号:全局维度(warehouse_id=0)按「前缀+日期」递增,唯一键串行化并发事务
|
||
await this.ctx.model.query(
|
||
`INSERT INTO wms_number_sequence (warehouse_id, biz_type, date_part, current_seq, created_at, updated_at)
|
||
VALUES (:warehouseId, :bizType, :datePart, LAST_INSERT_ID(:seed + 1), NOW(), NOW())
|
||
ON DUPLICATE KEY UPDATE current_seq = LAST_INSERT_ID(GREATEST(current_seq, :seed) + 1), updated_at = NOW()`,
|
||
{
|
||
replacements: {
|
||
warehouseId: 0,
|
||
bizType,
|
||
datePart: normalizedDatePart,
|
||
seed,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const seqRows = await this.ctx.model.query(
|
||
'SELECT LAST_INSERT_ID() AS seq',
|
||
{
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
const sequence = Number(seqRows && seqRows[0] && seqRows[0].seq || 0);
|
||
if (!Number.isInteger(sequence) || sequence <= 0) {
|
||
return 1;
|
||
}
|
||
|
||
return sequence;
|
||
}
|
||
|
||
/**
|
||
* 构建波次编号。
|
||
*
|
||
* @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;
|
||
}
|
||
|
||
/**
|
||
* 判断数据库错误是否为唯一键冲突(重复键 ER_DUP_ENTRY)。
|
||
*
|
||
* @param {*} error 数据库异常对象。
|
||
* @return {boolean} 是否唯一键冲突。
|
||
*/
|
||
isDuplicateEntryError(error) {
|
||
const errno = Number(
|
||
error && (error.original && error.original.errno || error.parent && error.parent.errno || error.errno) || 0
|
||
);
|
||
const code = String(
|
||
error && (error.original && error.original.code || error.parent && error.parent.code || error.code) || ''
|
||
);
|
||
return errno === 1062 || code === 'ER_DUP_ENTRY';
|
||
}
|
||
|
||
/**
|
||
* 新增一条“已就绪”波次批次记录,并返回自增 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 {number|string} [params.source=0] 波次来源:0-普通波次 1-管理后台策略任务 2-PDA策略任务。
|
||
* @param {Object} params.transaction Sequelize 事务。
|
||
* @return {Promise<{waveId: number, waveNo: string}>} 创建结果。
|
||
*/
|
||
async createWaveBatchReady({
|
||
warehouseId,
|
||
totalOrders,
|
||
itemDetailMachine,
|
||
itemPartType,
|
||
itemPart,
|
||
distinguishExpress,
|
||
logisticsName,
|
||
itemSnapshotKey,
|
||
wavePrefix,
|
||
waveNo,
|
||
waveType,
|
||
source,
|
||
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;
|
||
const normalizedSourceInput = Number(source);
|
||
const normalizedSource = [ 0, 1, 2 ].includes(normalizedSourceInput) ? normalizedSourceInput : 0;
|
||
const retryOnDuplicate = !normalizedWaveNoInput;
|
||
const maxWaveNoAttempts = retryOnDuplicate ? 3 : 1;
|
||
let normalizedWaveNo = normalizedWaveNoInput;
|
||
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,
|
||
source,
|
||
create_time,
|
||
update_time
|
||
)
|
||
VALUES
|
||
(
|
||
:waveNo,
|
||
:waveType,
|
||
1,
|
||
:totalOrders,
|
||
0,
|
||
:itemDetailMachine,
|
||
:itemPartType,
|
||
:itemPart,
|
||
:distinguishExpress,
|
||
:logisticsName,
|
||
:itemSnapshotKey,
|
||
:warehouseId,
|
||
:creator,
|
||
:source,
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`;
|
||
|
||
// 撞号重试:唯一索引兜底下,并发撞号时自动重新取号(最多 3 次)
|
||
let createResult = null;
|
||
for (let attempt = 1; attempt <= maxWaveNoAttempts; attempt += 1) {
|
||
if (!normalizedWaveNo) {
|
||
const datePart = this.getCurrentDatePart();
|
||
const sequence = await this.getNextWaveNoSequence(normalizedWavePrefix, datePart, transaction);
|
||
normalizedWaveNo = this.buildWaveNo(normalizedWavePrefix, datePart, sequence);
|
||
}
|
||
|
||
try {
|
||
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,
|
||
source: normalizedSource,
|
||
},
|
||
transaction,
|
||
});
|
||
break;
|
||
} catch (error) {
|
||
const isDuplicateWaveNo = this.isDuplicateEntryError(error);
|
||
if (!retryOnDuplicate || !isDuplicateWaveNo || attempt >= maxWaveNoAttempts) {
|
||
throw error;
|
||
}
|
||
|
||
this.ctx.logger.warn(
|
||
'[wave.createWaveBatchReady] 波次编号 %s 已存在(撞号),自动重新取号重试 %d/%d',
|
||
normalizedWaveNo,
|
||
attempt,
|
||
maxWaveNoAttempts
|
||
);
|
||
normalizedWaveNo = '';
|
||
}
|
||
}
|
||
|
||
let insertedWaveId = this.extractInsertId(createResult);
|
||
if (!Number.isInteger(insertedWaveId) || insertedWaveId <= 0) {
|
||
const fallbackResult = await this.ctx.model.query('SELECT LAST_INSERT_ID() AS insertId', {
|
||
transaction,
|
||
});
|
||
insertedWaveId = this.extractLastInsertId(fallbackResult);
|
||
}
|
||
|
||
if (!Number.isInteger(insertedWaveId) || insertedWaveId <= 0) {
|
||
throw new Error('创建波次失败,未获取到自增 wave_id');
|
||
}
|
||
|
||
return {
|
||
waveId: insertedWaveId,
|
||
waveNo: normalizedWaveNo,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建抓取候选订单筛选条件。
|
||
*
|
||
* @param {Object} structure 结构化请求。
|
||
* @return {Object} Sequelize where 条件。
|
||
*/
|
||
buildFetchWhere(structure = {}) {
|
||
const where = {
|
||
step: { [Op.in]: [ 1, 2, 3 ] },
|
||
status: { [Op.ne]: 'cancel' },
|
||
outbound_status: { [Op.ne]: 'padding' },
|
||
intercept_status: 'none',
|
||
lock_status: 'none',
|
||
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) {
|
||
const expressCode = String(structure.logistics_name || '').trim();
|
||
if (expressCode) {
|
||
where.sys_logistics_code = expressCode;
|
||
}
|
||
}
|
||
|
||
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 表示不限制。
|
||
* @param {number|string} [options.source=0] 波次来源:0-普通波次 1-管理后台策略任务 2-PDA策略任务。
|
||
* @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 normalizedSourceInput = Number(normalizedOptions.source);
|
||
const normalizedSource = [ 0, 1, 2 ].includes(normalizedSourceInput) ? normalizedSourceInput : 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,
|
||
source: normalizedSource,
|
||
transaction,
|
||
});
|
||
await model.update({
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
}, {
|
||
where: {
|
||
id: { [Op.in]: candidateOrderIds },
|
||
wave_id: 0,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const grabbedRows = await model.findAll({
|
||
where: {
|
||
id: { [Op.in]: candidateOrderIds },
|
||
wave_id: waveId,
|
||
},
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
const grabbedOrderIds = grabbedRows
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)
|
||
.sort((a, b) => a - b);
|
||
|
||
const fetchedQuantity = grabbedOrderIds.length;
|
||
if (fetchedQuantity <= 0) {
|
||
await this.ctx.model.query(`
|
||
DELETE FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
`, {
|
||
replacements: { waveId },
|
||
transaction,
|
||
});
|
||
|
||
if (totalFetchedQuantity === 0) {
|
||
stopReason = '无可抓取订单';
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (fetchedQuantity !== candidateOrderIds.length) {
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_batch
|
||
SET total_orders = :totalOrders,
|
||
update_time = NOW()
|
||
WHERE wave_id = :waveId
|
||
`, {
|
||
replacements: {
|
||
waveId,
|
||
totalOrders: fetchedQuantity,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
allWaveIds.push(waveId);
|
||
allOrderIds.push(...grabbedOrderIds);
|
||
fetchedOrderLogItems.push(...grabbedOrderIds.map(orderId => ({
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_ASSIGN',
|
||
message: `订单被分配到波次 ${waveNo}`,
|
||
})));
|
||
totalFetchedQuantity += fetchedQuantity;
|
||
if (normalizedMaxFetchQuantity > 0) {
|
||
remainingFetchQuantity -= fetchedQuantity;
|
||
if (remainingFetchQuantity <= 0) {
|
||
stopReason = '达到最大抓取上限';
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (allWaveIds.length > 0 && allOrderIds.length > 0) {
|
||
await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: allWaveIds,
|
||
orderModel: model,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
await transaction.commit();
|
||
await this.batchCreateOrderOperationLogs(fetchedOrderLogItems, {
|
||
warehouseId,
|
||
scene: 'fetchSingleStructure',
|
||
});
|
||
|
||
const mergedOrderIds = [ ...new Set(allOrderIds) ].sort((a, b) => a - b);
|
||
this.enqueueWaveStrategyQuickScanPostOrderChange(warehouseId, mergedOrderIds, {
|
||
triggerScan: false,
|
||
source: 'fetchSingleStructure',
|
||
});
|
||
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,
|
||
...(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) {
|
||
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'storage');
|
||
}
|
||
|
||
/**
|
||
* 规范化波次列表快递分配状态筛选值(英文枚举)。
|
||
*
|
||
* @param {string} value 入参筛选值。
|
||
* @return {string} 规范化后的筛选值,未传时返回空字符串。
|
||
*/
|
||
normalizeBatchListExpressAssignmentStatusFilter(value) {
|
||
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'express');
|
||
}
|
||
|
||
/**
|
||
* 规范化波次列表打印状态筛选值(英文枚举)。
|
||
*
|
||
* @param {string} value 入参筛选值。
|
||
* @return {string} 规范化后的筛选值,未传时返回空字符串。
|
||
*/
|
||
normalizeBatchListPrintAssignmentStatusFilter(value) {
|
||
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'print');
|
||
}
|
||
|
||
/**
|
||
* 规范化波次列表复核状态筛选值(英文枚举)。
|
||
*
|
||
* @param {string} value 入参筛选值。
|
||
* @return {string} 规范化后的筛选值,未传时返回空字符串。
|
||
*/
|
||
normalizeBatchListReviewAssignmentStatusFilter(value) {
|
||
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'review');
|
||
}
|
||
|
||
/**
|
||
* 根据类型获取波次分配状态筛选配置。
|
||
*
|
||
* @param {'storage'|'express'|'print'} type 筛选类型。
|
||
* @return {{ fieldName: string, enumMap: Object, caseInsensitive: boolean, statsColumnPrefix: string, withErrorStatus: boolean }} 筛选配置。
|
||
*/
|
||
getBatchListAssignmentFilterSchema(type) {
|
||
const normalizedType = String(type || '').trim();
|
||
const schema = BATCH_LIST_ASSIGNMENT_FILTER_SCHEMAS[normalizedType];
|
||
if (!schema) {
|
||
throw new Error(`不支持的分配状态筛选类型: ${normalizedType}`);
|
||
}
|
||
return schema;
|
||
}
|
||
|
||
/**
|
||
* 按类型规范化波次列表分配状态筛选值。
|
||
*
|
||
* @param {string} value 入参筛选值。
|
||
* @param {'storage'|'express'|'print'} type 筛选类型。
|
||
* @return {string} 规范化后的筛选值,未传时返回空字符串。
|
||
*/
|
||
normalizeBatchListAssignmentStatusFilterByType(value, type) {
|
||
const schema = this.getBatchListAssignmentFilterSchema(type);
|
||
return this.normalizeBatchListAssignmentStatusFilter(value, schema);
|
||
}
|
||
|
||
/**
|
||
* 规范化波次列表分配状态筛选值。
|
||
*
|
||
* @param {string} value 入参筛选值。
|
||
* @param {{ fieldName: string, enumMap: Object, caseInsensitive: boolean }} schema 筛选配置。
|
||
* @return {string} 规范化后的筛选标识(none/partial/finished)。
|
||
*/
|
||
normalizeBatchListAssignmentStatusFilter(value, schema) {
|
||
if (value === undefined || value === null || value === '') {
|
||
return '';
|
||
}
|
||
|
||
const normalizedValue = String(value).trim();
|
||
if (!normalizedValue) {
|
||
return '';
|
||
}
|
||
|
||
const enumMap = this.isPlainObject(schema && schema.enumMap) ? schema.enumMap : {};
|
||
const allowedValues = Object.keys(enumMap);
|
||
const isCaseInsensitive = Boolean(schema && schema.caseInsensitive);
|
||
const lookupValue = isCaseInsensitive ? normalizedValue.toLowerCase() : normalizedValue;
|
||
const normalizedEnumMap = isCaseInsensitive
|
||
? Object.fromEntries(
|
||
Object.entries(enumMap).map(([ key, mappedValue ]) => [ String(key).toLowerCase(), mappedValue ])
|
||
)
|
||
: enumMap;
|
||
const matchedValue = normalizedEnumMap[lookupValue];
|
||
|
||
if (!matchedValue) {
|
||
const fieldName = String(schema && schema.fieldName || 'assignment_status');
|
||
throw new Error(`${fieldName} 参数不合法,仅支持: ${allowedValues.join('、')}`);
|
||
}
|
||
|
||
return matchedValue;
|
||
}
|
||
|
||
/**
|
||
* 解析模型对应的 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 = '') {
|
||
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'storage');
|
||
}
|
||
|
||
/**
|
||
* 构建波次列表快递分配状态筛选 SQL 条件。
|
||
*
|
||
* @param {string} statusFilter 快递分配状态筛选值(none/partial/finished)。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildBatchListExpressAssignmentFilterClause(statusFilter = '') {
|
||
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'express');
|
||
}
|
||
|
||
/**
|
||
* 构建波次列表打印状态筛选 SQL 条件。
|
||
*
|
||
* @param {string} statusFilter 打印状态筛选值(none/partial/finished)。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildBatchListPrintAssignmentFilterClause(statusFilter = '') {
|
||
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'print');
|
||
}
|
||
|
||
/**
|
||
* 构建波次列表复核状态筛选 SQL 条件。
|
||
*
|
||
* @param {string} statusFilter 复核状态筛选值(none/partial/finished)。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildBatchListReviewAssignmentFilterClause(statusFilter = '') {
|
||
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'review');
|
||
}
|
||
|
||
/**
|
||
* 按类型构建波次列表分配状态筛选 SQL 条件。
|
||
*
|
||
* @param {string} statusFilter 分配状态筛选值(none/partial/finished)。
|
||
* @param {'storage'|'express'|'print'} type 筛选类型。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildBatchListAssignmentStatusFilterClauseByType(statusFilter = '', type = 'storage') {
|
||
const schema = this.getBatchListAssignmentFilterSchema(type);
|
||
return this.buildBatchListAssignmentStatusFilterClause(statusFilter, schema);
|
||
}
|
||
|
||
/**
|
||
* 构建波次列表分配状态筛选 SQL 条件(通用)。
|
||
*
|
||
* @param {string} statusFilter 分配状态筛选值(none/partial/finished)。
|
||
* @param {{ statsColumnPrefix: string, withErrorStatus: boolean }} schema 筛选配置。
|
||
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
|
||
*/
|
||
buildBatchListAssignmentStatusFilterClause(statusFilter = '', schema = {}) {
|
||
const normalizedStatusFilter = String(statusFilter || '').trim();
|
||
if (!normalizedStatusFilter) {
|
||
return {
|
||
sql: '',
|
||
replacements: {},
|
||
};
|
||
}
|
||
|
||
const statsPrefix = String(schema && schema.statsColumnPrefix || '').trim();
|
||
if (!statsPrefix) {
|
||
throw new Error('分配状态筛选配置不完整,缺少统计字段前缀');
|
||
}
|
||
|
||
const totalExpr = 'COALESCE(wave_order_stats.order_total, 0)';
|
||
const noneExpr = `COALESCE(wave_order_stats.${statsPrefix}_none_count, 0)`;
|
||
const finExpr = `COALESCE(wave_order_stats.${statsPrefix}_fin_count, 0)`;
|
||
const withErrorStatus = Boolean(schema && schema.withErrorStatus);
|
||
const errorExpr = withErrorStatus ? `COALESCE(wave_order_stats.${statsPrefix}_error_count, 0)` : '';
|
||
|
||
if (normalizedStatusFilter === 'finished') {
|
||
return {
|
||
sql: `
|
||
AND ${finExpr} = ${totalExpr}
|
||
AND ${totalExpr} > 0`,
|
||
replacements: {},
|
||
};
|
||
}
|
||
|
||
if (normalizedStatusFilter === 'partial') {
|
||
return {
|
||
sql: `
|
||
AND ${withErrorStatus ? `${errorExpr} = 0\n AND ` : ''}${noneExpr} <> ${totalExpr}
|
||
AND ${finExpr} <> ${totalExpr}`,
|
||
replacements: {},
|
||
};
|
||
}
|
||
|
||
if (normalizedStatusFilter === 'none') {
|
||
return {
|
||
sql: `
|
||
AND (
|
||
${totalExpr} = 0
|
||
${withErrorStatus ? `OR ${errorExpr} > 0\n ` : ''}OR ${noneExpr} = ${totalExpr}
|
||
)`,
|
||
replacements: {},
|
||
};
|
||
}
|
||
|
||
throw new Error(`不支持的分配状态筛选值: ${normalizedStatusFilter}`);
|
||
}
|
||
|
||
/**
|
||
* 构建波次列表 where 条件(白名单字段)。
|
||
*
|
||
* @param {Object} whereData 查询 where 入参。
|
||
* @return {{ sql: string, replacements: Object, storageAssignmentStatus: string, expressAssignmentStatus: string, printAssignmentStatus: string, reviewAssignmentStatus: string, storeIds: number[] }} SQL 条件片段、参数与分配状态筛选值。
|
||
*/
|
||
buildBatchListWhereClause(whereData = {}) {
|
||
const normalizedWhere = this.isPlainObject(whereData) ? whereData : {};
|
||
const whereKeys = Object.keys(normalizedWhere);
|
||
|
||
if (whereKeys.includes('warehouse_id') || whereKeys.includes('warehouseId')) {
|
||
throw new Error('where 中禁止传入 warehouse_id 或 warehouseId');
|
||
}
|
||
|
||
const allowedFields = [
|
||
'wave_id',
|
||
'wave_no',
|
||
'wave_type',
|
||
'wave_status',
|
||
'creator',
|
||
'logistics_name',
|
||
'item_part_type',
|
||
'item_part',
|
||
'item_snapshot_key',
|
||
'item_detail_machine',
|
||
'distinguish_express',
|
||
'source',
|
||
'total_orders_min',
|
||
'total_orders_max',
|
||
'processed_orders_min',
|
||
'processed_orders_max',
|
||
'storage_assignment_status',
|
||
'express_assignment_status',
|
||
'print_assignment_status',
|
||
'review_assignment_status',
|
||
'store_id',
|
||
];
|
||
|
||
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');
|
||
appendIntegerEqualCondition('source', 'source', 'whereSource', true);
|
||
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');
|
||
|
||
// store_id 货主筛选:支持单值/数组/{operator,value} 结构,归一化为正整数数组(去重)。
|
||
// 过滤语义:返回包含任一筛选货主订单的波次(含混合货主波次)。
|
||
const normalizeStoreIdList = value => {
|
||
if (value === undefined || value === null || value === '') {
|
||
return [];
|
||
}
|
||
|
||
const rawValue = this.isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, 'value')
|
||
? value.value
|
||
: value;
|
||
const sourceList = Array.isArray(rawValue) ? rawValue : [ rawValue ];
|
||
const normalizedIds = [];
|
||
|
||
for (const item of sourceList) {
|
||
if (item === undefined || item === null || item === '') {
|
||
continue;
|
||
}
|
||
|
||
const numberValue = Number(String(item).trim());
|
||
if (!Number.isInteger(numberValue) || numberValue <= 0) {
|
||
throw new Error('store_id 参数不合法');
|
||
}
|
||
|
||
normalizedIds.push(numberValue);
|
||
}
|
||
|
||
return [ ...new Set(normalizedIds) ];
|
||
};
|
||
|
||
const storeIds = normalizeStoreIdList(normalizedWhere.store_id);
|
||
|
||
const storageAssignmentStatus = this.normalizeBatchListStorageAssignmentStatusFilter(
|
||
normalizedWhere.storage_assignment_status
|
||
);
|
||
const expressAssignmentStatus = this.normalizeBatchListExpressAssignmentStatusFilter(
|
||
normalizedWhere.express_assignment_status
|
||
);
|
||
const printAssignmentStatus = this.normalizeBatchListPrintAssignmentStatusFilter(
|
||
normalizedWhere.print_assignment_status
|
||
);
|
||
const reviewAssignmentStatus = this.normalizeBatchListReviewAssignmentStatusFilter(
|
||
normalizedWhere.review_assignment_status
|
||
);
|
||
|
||
return {
|
||
sql: conditions.length > 0 ? `\n AND ${conditions.join('\n AND ')}` : '',
|
||
replacements,
|
||
storageAssignmentStatus,
|
||
expressAssignmentStatus,
|
||
printAssignmentStatus,
|
||
reviewAssignmentStatus,
|
||
storeIds,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 解析拣货任务列表分页参数。
|
||
*
|
||
* 兼容 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,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 归一化拣货任务列表请求参数。
|
||
*
|
||
* 兼容顶层筛选参数与 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,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 解析分配状态。
|
||
*
|
||
* @param {number} total 总数量。
|
||
* @param {number} noneCount 未分配数量。
|
||
* @param {number} finCount 已分配数量。
|
||
* @param {number} errorCount 分配异常数量。
|
||
* @param {{ none?: string, partial?: string, finished?: string, error?: string }} [labels] 状态文案映射。
|
||
* @return {string} 分配状态。
|
||
*/
|
||
resolveAssignmentStatus(total, noneCount, finCount, errorCount = 0, labels = {}) {
|
||
const normalizedTotal = Number(total || 0);
|
||
const normalizedNoneCount = Number(noneCount || 0);
|
||
const normalizedFinCount = Number(finCount || 0);
|
||
const normalizedErrorCount = Number(errorCount || 0);
|
||
const normalizedLabels = labels && typeof labels === 'object' ? labels : {};
|
||
const noneLabel = String(normalizedLabels.none || '未分配');
|
||
const partialLabel = String(normalizedLabels.partial || '部分分配');
|
||
const finishedLabel = String(normalizedLabels.finished || '已分配');
|
||
const errorLabel = String(normalizedLabels.error || '分配异常');
|
||
|
||
if (normalizedErrorCount > 0) {
|
||
return errorLabel;
|
||
}
|
||
|
||
if (normalizedTotal <= 0 || normalizedNoneCount === normalizedTotal) {
|
||
return noneLabel;
|
||
}
|
||
|
||
if (normalizedFinCount === normalizedTotal) {
|
||
return finishedLabel;
|
||
}
|
||
|
||
return partialLabel;
|
||
}
|
||
|
||
normalizeSkuText(value) {
|
||
if (value === undefined || value === null) {
|
||
return '';
|
||
}
|
||
|
||
return String(value).trim();
|
||
}
|
||
|
||
normalizeShopName(value) {
|
||
if (value === undefined || value === null) {
|
||
return '';
|
||
}
|
||
|
||
return String(value).trim();
|
||
}
|
||
|
||
parseItemSnapshot(rawSnapshot) {
|
||
if (!rawSnapshot) {
|
||
return {};
|
||
}
|
||
|
||
if (typeof rawSnapshot === 'string') {
|
||
try {
|
||
const parsed = JSON.parse(rawSnapshot);
|
||
return parsed && typeof parsed === 'object' ? parsed : {};
|
||
} catch {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
return typeof rawSnapshot === 'object' ? rawSnapshot : {};
|
||
}
|
||
|
||
normalizeOrderItemRow(row = {}) {
|
||
const snapshot = this.parseItemSnapshot(row.item_snapshot);
|
||
const stockIdRaw = snapshot.stock_id ?? row.stock_id;
|
||
const quantityRaw = row.plan_qty;
|
||
|
||
const stockId = Number(stockIdRaw || 0);
|
||
const quantity = Number(quantityRaw || 0);
|
||
|
||
return {
|
||
stock_id: Number.isInteger(stockId) && stockId > 0 ? stockId : 0,
|
||
item_code: String(snapshot.item_code ?? row.item_code ?? '').trim(),
|
||
item_name: String(snapshot.item_name ?? row.item_name ?? '').trim(),
|
||
barcode: String(snapshot.barcode ?? '').trim(),
|
||
quantity: Number.isFinite(quantity) && quantity > 0 ? quantity : 0,
|
||
};
|
||
}
|
||
|
||
mergeOrderItemDetails(itemRows = []) {
|
||
const merged = new Map();
|
||
|
||
for (const row of itemRows) {
|
||
const normalized = this.normalizeOrderItemRow(row);
|
||
const hasIdentity = normalized.stock_id > 0
|
||
|| normalized.item_code
|
||
|| normalized.item_name;
|
||
|
||
if (!hasIdentity || 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('|');
|
||
}
|
||
|
||
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.sys_logistics_code || '').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.sys_logistics_code || '').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 stockQuery = String(requestData.stock_query || '').trim();
|
||
const { page, pageSize } = this.normalizePagination(requestData);
|
||
|
||
const where = {
|
||
step: { [Op.in]: [ 1, 2, 3 ] },
|
||
status: { [Op.ne]: 'cancel' },
|
||
outbound_status: { [Op.ne]: 'padding' },
|
||
intercept_status: 'none',
|
||
lock_status: 'none',
|
||
wave_id: 0,
|
||
};
|
||
|
||
if (storeId > 0) {
|
||
where.store_id = storeId;
|
||
}
|
||
|
||
if (shopName) {
|
||
where.shop_nick = { [Op.like]: `%${shopName}%` };
|
||
}
|
||
|
||
// stock_query 商品模糊筛选:通过 stock_warehouse / stock_barcodes → order_items → 限定候选订单范围
|
||
if (stockQuery) {
|
||
const stockOrderIds = await this.findOrderIdsByStockQuery(stockQuery, 'order', warehouseId);
|
||
if (stockOrderIds.length > 0) {
|
||
where.id = { [Op.in]: stockOrderIds };
|
||
} else {
|
||
// 未匹配到任何商品,直接返回空列表
|
||
return {
|
||
list: [],
|
||
pagination: { page, pageSize, total: 0, totalPages: 0, hasPrevious: false, hasNext: false },
|
||
};
|
||
}
|
||
}
|
||
|
||
// Phase 1: 主表全量查询,用 items_hash 做分组基准
|
||
const rawOrders = await model.findAll({
|
||
where,
|
||
attributes: [
|
||
'id', 'store_id', 'logistics_name',
|
||
'sys_logistics_code', 'sys_logistics_name',
|
||
'items_hash', 'items', 'items_total', 'items_weight',
|
||
'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 firstOrder = g.orders[0] || {};
|
||
const itemPartInfo = this.getOrderItemPart(firstOrder);
|
||
const logisticsCode = String(firstOrder.sys_logistics_code || '').trim();
|
||
const logisticsNameFromOrder = String(firstOrder.sys_logistics_name || '').trim();
|
||
const logisticsDisplayName = logisticsNameFromOrder || logisticsCode;
|
||
const itemDetailMachine = this.buildMachineStructureToken({
|
||
item_part_type: itemPartInfo.item_part_type,
|
||
item_part: itemPartInfo.item_part,
|
||
distinguish_express: distinguishExpress,
|
||
logistics_name: logisticsCode,
|
||
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,
|
||
items_weight: firstOrder.items_weight != null ? Number(firstOrder.items_weight) : null,
|
||
store_id: store_ids.length === 1 ? store_ids[0] : 0,
|
||
store_ids,
|
||
logistics_code: logisticsCode,
|
||
logistics_name: logisticsDisplayName,
|
||
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 stockQuery = String(requestData.stock_query || '').trim();
|
||
const { page, pageSize } = this.normalizePagination(requestData);
|
||
|
||
const where = {
|
||
step: { [Op.in]: [ 1, 2, 3 ] },
|
||
status: { [Op.ne]: 'cancel' },
|
||
outbound_status: { [Op.ne]: 'padding' },
|
||
intercept_status: 'none',
|
||
lock_status: 'none',
|
||
wave_id: 0,
|
||
};
|
||
|
||
if (storeId > 0) {
|
||
where.store_id = storeId;
|
||
}
|
||
|
||
if (shopName) {
|
||
where.shop_nick = { [Op.like]: `%${shopName}%` };
|
||
}
|
||
|
||
// stock_query 商品模糊筛选:通过 stock_warehouse / stock_barcodes → order_items → 限定候选订单范围
|
||
if (stockQuery) {
|
||
const stockOrderIds = await this.findOrderIdsByStockQuery(stockQuery, 'order', warehouseId);
|
||
if (stockOrderIds.length > 0) {
|
||
where.id = { [Op.in]: stockOrderIds };
|
||
} else {
|
||
// 未匹配到任何商品,直接返回空列表
|
||
return {
|
||
list: [],
|
||
pagination: { page, pageSize, total: 0, totalPages: 0, hasPrevious: false, hasNext: false },
|
||
};
|
||
}
|
||
}
|
||
|
||
// Phase 1: 主表全量查询,用 items_hash 做分组基准
|
||
const rawOrders = await model.findAll({
|
||
where,
|
||
attributes: [
|
||
'id', 'store_id', 'logistics_name',
|
||
'sys_logistics_code', 'sys_logistics_name',
|
||
'items_hash', 'items', 'items_total', 'items_weight',
|
||
'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 firstOrder = g.orders[0] || {};
|
||
const itemPartInfo = this.getOrderItemPart(firstOrder);
|
||
const logisticsCode = String(firstOrder.sys_logistics_code || '').trim();
|
||
const logisticsNameFromOrder = String(firstOrder.sys_logistics_name || '').trim();
|
||
const logisticsDisplayName = logisticsNameFromOrder || logisticsCode;
|
||
const itemDetailMachine = this.buildMachineStructureToken({
|
||
item_part_type: itemPartInfo.item_part_type,
|
||
item_part: itemPartInfo.item_part,
|
||
distinguish_express: distinguishExpress,
|
||
logistics_name: logisticsCode,
|
||
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,
|
||
items_weight: firstOrder.items_weight != null ? Number(firstOrder.items_weight) : null,
|
||
store_id: store_ids.length === 1 ? store_ids[0] : 0,
|
||
store_ids,
|
||
logistics_code: logisticsCode,
|
||
logistics_name: logisticsDisplayName,
|
||
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 rawType = requestData.strategy_type ?? requestData?.where?.strategy_type;
|
||
let normalizedStrategyType;
|
||
if (rawType !== undefined && rawType !== null && `${rawType}` !== '') {
|
||
normalizedStrategyType = Number(rawType);
|
||
if (![ 1, 2 ].includes(normalizedStrategyType)) {
|
||
throw new Error('strategy_type 仅支持 1(散单) 或 2(团购)');
|
||
}
|
||
}
|
||
const calculateNextFetchOrderCount = Number(
|
||
requestData.calculate_next_fetch_order_count ?? requestData.calculateNextFetchOrderCount ?? 0
|
||
) === 1;
|
||
const debugEnabled = Number(requestData.debug ?? 0) === 1;
|
||
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 where = {
|
||
warehouse_id: contextWarehouseId,
|
||
};
|
||
if (normalizedStrategyType !== undefined) {
|
||
where.strategy_type = normalizedStrategyType;
|
||
}
|
||
|
||
const queryResult = await strategyModel.findAndCountAll({
|
||
where,
|
||
order: [
|
||
[ 'status', 'DESC' ],
|
||
[ 'id', 'DESC' ],
|
||
],
|
||
offset,
|
||
limit: pageSize,
|
||
raw: true,
|
||
});
|
||
|
||
const list = Array.isArray(queryResult && queryResult.rows) ? queryResult.rows : [];
|
||
const matchedOrderCountMap = await this.getWaveStrategyMatchedOrderCountFilteredMap(
|
||
contextWarehouseId,
|
||
list
|
||
);
|
||
const nextFetchOrderCountMap = calculateNextFetchOrderCount
|
||
? await this.getWaveStrategyNextFetchOrderCountMap(contextWarehouseId, list)
|
||
: new Map();
|
||
const debugFetchOrderListMap = debugEnabled
|
||
? await this.getWaveStrategyDebugFetchOrderListMap(contextWarehouseId, list)
|
||
: new Map();
|
||
const mergedList = list.map(item => {
|
||
const strategyId = Number(item && item.id || 0);
|
||
const debugRow = debugEnabled ? (debugFetchOrderListMap.get(strategyId) || null) : null;
|
||
return {
|
||
...item,
|
||
matched_order_count_filtered: Number(
|
||
matchedOrderCountMap.get(strategyId) || 0
|
||
),
|
||
next_fetch_order_count: calculateNextFetchOrderCount
|
||
? Number(nextFetchOrderCountMap.get(strategyId) || 0)
|
||
: 0,
|
||
...(debugEnabled && debugRow ? {
|
||
next_fetch_order_list: debugRow,
|
||
} : {}),
|
||
};
|
||
});
|
||
const total = Number(queryResult && queryResult.count || 0);
|
||
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
|
||
|
||
return this.success('ok', {
|
||
list: mergedList,
|
||
pagination: {
|
||
page,
|
||
pageSize,
|
||
total,
|
||
totalPages,
|
||
hasPrevious: page > 1,
|
||
hasNext: page < totalPages,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 批量预演当前页策略“下一个抓取订单数”。
|
||
*
|
||
* 仅执行候选查询与规则计算,不写库、不建波次、不占锁。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {Array<Object>} [strategyRows=[]] 策略行数组。
|
||
* @return {Promise<Map<number, number>>} strategy_id 到预演订单数映射。
|
||
*/
|
||
async getWaveStrategyNextFetchOrderCountMap(warehouseId, strategyRows = []) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const rows = Array.isArray(strategyRows) ? strategyRows : [];
|
||
const countMap = new Map();
|
||
|
||
await Promise.all(rows.map(async row => {
|
||
const strategyId = Number(row && row.id || 0);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const nextFetchOrderCount = await this.previewWaveStrategyNextFetchOrderCount({
|
||
warehouseId: normalizedWarehouseId,
|
||
strategyRow: row,
|
||
});
|
||
countMap.set(strategyId, Number(nextFetchOrderCount || 0));
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.getWaveStrategyNextFetchOrderCountMap] 预演策略抓取数量失败,降级为 0', {
|
||
warehouse_id: normalizedWarehouseId,
|
||
strategy_id: strategyId,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
});
|
||
countMap.set(strategyId, 0);
|
||
}
|
||
}));
|
||
|
||
return countMap;
|
||
}
|
||
|
||
/**
|
||
* 调试:按策略返回候选订单明细列表(含结构、快递、货主等指标)。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {Array<Object>} [strategyRows=[]] 策略行数组。
|
||
* @return {Promise<Map<number, Array<Object>>>} strategy_id 到候选订单明细列表的映射。
|
||
*/
|
||
async getWaveStrategyDebugFetchOrderListMap(warehouseId, strategyRows = []) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const rows = Array.isArray(strategyRows) ? strategyRows : [];
|
||
const orderListMap = new Map();
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', normalizedWarehouseId);
|
||
const orderTableName = this.getModelTableSqlName(orderModel);
|
||
|
||
await Promise.all(rows.map(async row => {
|
||
const strategyId = Number(row && row.id || 0);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const candidateRows = await this.ctx.model.query(`
|
||
SELECT
|
||
o.id,
|
||
o.items_hash,
|
||
o.items,
|
||
o.logistics_name,
|
||
o.logistics_code,
|
||
o.sys_logistics_code,
|
||
o.store_id,
|
||
o.items_count,
|
||
o.items_total,
|
||
o.wave_id,
|
||
o.step,
|
||
o.status,
|
||
o.outbound_status,
|
||
o.post_status,
|
||
o.storage_status,
|
||
o.print_status
|
||
FROM wms_order_wave_strategy_match m
|
||
INNER JOIN ${orderTableName} o
|
||
ON o.id = m.order_id
|
||
AND o.warehouse_id = :warehouseId
|
||
AND o.wave_id = 0
|
||
AND o.step != 0
|
||
AND o.post_status = 'fin'
|
||
AND o.storage_status = 'fin'
|
||
AND o.print_status != 'fin'
|
||
AND o.status != 'cancel'
|
||
AND o.outbound_status != 'padding'
|
||
AND o.intercept_status = 'none'
|
||
AND o.lock_status = 'none'
|
||
WHERE m.warehouse_id = :warehouseId
|
||
AND m.strategy_id = :strategyId
|
||
ORDER BY o.id ASC
|
||
LIMIT 500
|
||
`, {
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
strategyId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
const normalizedRows = Array.isArray(candidateRows) ? candidateRows : [];
|
||
const requireSameExpress = Number(row && row.require_same_express || 0) === 1;
|
||
const filteredRows = requireSameExpress && normalizedRows.length > 0
|
||
? (() => {
|
||
const expressGroupMap = new Map();
|
||
for (const order of normalizedRows) {
|
||
const expressKey = this.getWaveStrategyQuickScanExpressKey({
|
||
sys_logistics_code: order.sys_logistics_code,
|
||
logistics_code: order.logistics_code,
|
||
logistics_name: order.logistics_name,
|
||
});
|
||
const key = expressKey || '__empty__';
|
||
if (!expressGroupMap.has(key)) {
|
||
expressGroupMap.set(key, []);
|
||
}
|
||
expressGroupMap.get(key).push(order);
|
||
}
|
||
const groups = Array.from(expressGroupMap.values())
|
||
.sort((a, b) => b.length - a.length);
|
||
return groups.length > 0 ? groups[0] : normalizedRows;
|
||
})()
|
||
: normalizedRows;
|
||
const detailList = filteredRows.map(order => ({
|
||
order_id: Number(order && order.id || 0),
|
||
structure: {
|
||
items_hash: String(order && order.items_hash || '').trim(),
|
||
items: String(order && order.items || '').trim(),
|
||
},
|
||
express: {
|
||
sys_logistics_code: String(order && order.sys_logistics_code || '').trim(),
|
||
logistics_code: String(order && order.logistics_code || '').trim(),
|
||
logistics_name: String(order && order.logistics_name || '').trim(),
|
||
},
|
||
store_id: String(order && order.store_id || '').trim(),
|
||
items_count: Number(order && order.items_count || 0),
|
||
items_total: Number(order && order.items_total || 0),
|
||
wave_id: Number(order && order.wave_id || 0),
|
||
status: String(order && order.status || '').trim(),
|
||
outbound_status: String(order && order.outbound_status || '').trim(),
|
||
post_status: String(order && order.post_status || '').trim(),
|
||
storage_status: String(order && order.storage_status || '').trim(),
|
||
}));
|
||
|
||
orderListMap.set(strategyId, {
|
||
candidate_count: detailList.length,
|
||
candidate_total: normalizedRows.length,
|
||
candidates: detailList,
|
||
});
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.getWaveStrategyDebugFetchOrderListMap] 调试查询失败,降级为空', {
|
||
warehouse_id: normalizedWarehouseId,
|
||
strategy_id: strategyId,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
});
|
||
orderListMap.set(strategyId, { candidate_count: 0, candidates: [], error: error && error.message || `${error}` });
|
||
}
|
||
}));
|
||
|
||
return orderListMap;
|
||
}
|
||
|
||
/**
|
||
* 预演单个策略“下一个抓取订单数”。
|
||
*
|
||
* 口径复用自动分流逻辑,但仅计算最终会选中的订单数量,不执行写操作。
|
||
*
|
||
* @param {Object} [params={}] 预演参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Object} params.strategyRow 策略行。
|
||
* @return {Promise<number>} 预演可抓取订单数。
|
||
*/
|
||
async previewWaveStrategyNextFetchOrderCount(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const strategyRow = this.isPlainObject(params.strategyRow) ? params.strategyRow : {};
|
||
const strategyId = Number(strategyRow.id || 0);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
const strategyType = Number(strategyRow.strategy_type || 0);
|
||
if (![ 1, 2 ].includes(strategyType)) {
|
||
return 0;
|
||
}
|
||
|
||
const candidateRows = await this.getWaveStrategyFetchCandidateOrders({
|
||
warehouseId,
|
||
strategyId,
|
||
minSameStructure: strategyRow.min_same_structure,
|
||
maxSameStructure: strategyRow.max_same_structure,
|
||
requireSameExpress: Number(strategyRow.require_same_express || 0),
|
||
});
|
||
if (candidateRows.length <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
let groupedRows = this.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows);
|
||
if (groupedRows.length <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
if (Number(strategyRow.require_same_express || 0) === 1) {
|
||
const filteredRows = this.filterCandidateOrdersByRequireSameExpress(candidateRows);
|
||
groupedRows = this.groupWaveStrategyFetchCandidateOrdersByStructure(filteredRows);
|
||
if (groupedRows.length <= 0) {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
if (strategyType === 2) {
|
||
const groupLimitRaw = Number(strategyRow.group_batch_max_orders || 0);
|
||
const groupLimit = Number.isInteger(groupLimitRaw) && groupLimitRaw > 0 ? groupLimitRaw : 1;
|
||
const selectedGroups = groupedRows.slice(0, groupLimit);
|
||
const selectedOrderIds = [ ...new Set(selectedGroups
|
||
.flatMap(group => group.order_ids)
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
return selectedOrderIds.length;
|
||
}
|
||
|
||
const pickMode = this.resolveWaveStrategyFetchPickMode({
|
||
requestData: {},
|
||
strategyRow,
|
||
});
|
||
const mergedOrderIds = [ ...new Set(groupedRows
|
||
.flatMap(group => group.order_ids)
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
if (mergedOrderIds.length <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
let selectedOrderIds = [];
|
||
if (pickMode === 3) {
|
||
const skuMap = await this.buildWaveStrategyFetchOrderSkuMap({
|
||
warehouseId,
|
||
orderIds: mergedOrderIds,
|
||
});
|
||
const skuLimitRaw = Number(strategyRow.batch_max_skus || 0);
|
||
const skuLimit = Number.isInteger(skuLimitRaw) && skuLimitRaw > 0 ? skuLimitRaw : 0;
|
||
const skuResult = this.selectWaveStrategyFetchOrdersBySkuLimit({
|
||
orderIds: mergedOrderIds,
|
||
orderSkuMap: skuMap,
|
||
skuLimit,
|
||
});
|
||
selectedOrderIds = skuResult.selectedOrderIds;
|
||
} else if (pickMode === 2 || pickMode === 4) {
|
||
selectedOrderIds = mergedOrderIds;
|
||
} else {
|
||
return 0;
|
||
}
|
||
|
||
const orderLimitRaw = Number(strategyRow.batch_max_orders || 0);
|
||
const orderLimit = Number.isInteger(orderLimitRaw) && orderLimitRaw > 0 ? orderLimitRaw : 0;
|
||
const limitedOrderIds = orderLimit > 0
|
||
? selectedOrderIds.slice(0, orderLimit)
|
||
: selectedOrderIds;
|
||
|
||
return limitedOrderIds.length;
|
||
}
|
||
|
||
/**
|
||
* 按策略统计过滤后命中订单数。
|
||
*
|
||
* 过滤口径与抓取候选 SQL(getWaveStrategyFetchCandidateOrders)保持一致:
|
||
* 1) 仅统计未在波次订单(wave_id = 0);
|
||
* 2) 仅统计 step != 0 的订单;
|
||
* 3) 仅统计状态有效订单(status != cancel 且 outbound_status != padding);
|
||
* 4) 同结构数量需落在策略 min_same_structure/max_same_structure 区间内;
|
||
* 当 require_same_express = 1 时按「结构(items_hash) + 快递」分组计数,
|
||
* 否则仅按结构(items_hash)分组计数。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {Array<Object|number|string>} strategyRows 当前页策略行数组(含 require_same_express)。
|
||
* @return {Promise<Map<number, number>>} strategy_id 到过滤后命中订单数的映射。
|
||
*/
|
||
async getWaveStrategyMatchedOrderCountFilteredMap(warehouseId, strategyRows = []) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const normalizedStrategies = [ ...new Map((Array.isArray(strategyRows) ? strategyRows : [])
|
||
.map(item => {
|
||
const strategyId = Number(item && (item.id ?? item.strategy_id) || 0);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return null;
|
||
}
|
||
|
||
return [ strategyId, {
|
||
id: strategyId,
|
||
requireSameExpress: Number(item && item.require_same_express || 0) === 1,
|
||
}];
|
||
})
|
||
.filter(Boolean)).values() ];
|
||
if (normalizedStrategies.length === 0) {
|
||
return new Map();
|
||
}
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', normalizedWarehouseId);
|
||
const orderTableName = this.getModelTableSqlName(orderModel);
|
||
const expressExpr = alias => `COALESCE(NULLIF(TRIM(COALESCE(${alias}.sys_logistics_code, '')), ''), NULLIF(TRIM(COALESCE(${alias}.logistics_code, '')), ''), TRIM(COALESCE(${alias}.logistics_name, '')))`;
|
||
|
||
const matchedMap = new Map();
|
||
const runCountQuery = async (strategyGroup, requireSameExpress) => {
|
||
const strategyIds = strategyGroup.map(item => item.id);
|
||
if (strategyIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const groupKeyExtra = requireSameExpress ? `, ${expressExpr('src')} AS express_key` : '';
|
||
const joinKeyExtra = requireSameExpress ? ` AND same_structure.express_key = ${expressExpr('o')}` : '';
|
||
const querySql = `
|
||
SELECT
|
||
m.strategy_id,
|
||
COUNT(DISTINCT m.order_id) AS matched_order_count_filtered
|
||
FROM wms_order_wave_strategy_match m
|
||
INNER JOIN ${orderTableName} o
|
||
ON o.id = m.order_id
|
||
AND o.warehouse_id = :warehouseId
|
||
AND o.wave_id = 0
|
||
AND o.step != 0
|
||
AND o.post_status = 'fin'
|
||
AND o.storage_status = 'fin'
|
||
AND o.print_status != 'fin'
|
||
AND o.status != 'cancel'
|
||
AND o.outbound_status != 'padding'
|
||
AND o.intercept_status = 'none'
|
||
AND o.lock_status = 'none'
|
||
INNER JOIN (
|
||
SELECT
|
||
src.items_hash AS structure_key${groupKeyExtra},
|
||
COUNT(1) AS same_structure_count
|
||
FROM ${orderTableName} src
|
||
WHERE src.warehouse_id = :warehouseId
|
||
AND src.wave_id = 0
|
||
AND src.step != 0
|
||
AND src.post_status = 'fin'
|
||
AND src.storage_status = 'fin'
|
||
AND src.print_status != 'fin'
|
||
AND src.status != 'cancel'
|
||
AND src.outbound_status != 'padding'
|
||
AND src.intercept_status = 'none'
|
||
AND src.lock_status = 'none'
|
||
GROUP BY src.items_hash${requireSameExpress ? `, ${expressExpr('src')}` : ''}
|
||
) same_structure
|
||
ON same_structure.structure_key = o.items_hash${joinKeyExtra}
|
||
INNER JOIN wms_wave_strategy s
|
||
ON s.id = m.strategy_id
|
||
AND s.warehouse_id = :warehouseId
|
||
WHERE m.warehouse_id = :warehouseId
|
||
AND m.strategy_id IN (:strategyIds)
|
||
AND same_structure.same_structure_count >= COALESCE(NULLIF(s.min_same_structure, 0), 0)
|
||
AND (s.max_same_structure IS NULL OR s.max_same_structure <= 0 OR same_structure.same_structure_count <= s.max_same_structure)
|
||
GROUP BY m.strategy_id
|
||
`;
|
||
|
||
const queryRows = await this.ctx.model.query(querySql, {
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
strategyIds,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
(Array.isArray(queryRows) ? queryRows : []).forEach(row => {
|
||
const strategyId = Number(row && row.strategy_id || 0);
|
||
const matchedCount = Number(row && row.matched_order_count_filtered || 0);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return;
|
||
}
|
||
|
||
matchedMap.set(strategyId, matchedCount);
|
||
});
|
||
};
|
||
|
||
await Promise.all([
|
||
runCountQuery(normalizedStrategies.filter(item => item.requireSameExpress), true),
|
||
runCountQuery(normalizedStrategies.filter(item => !item.requireSameExpress), false),
|
||
]);
|
||
|
||
return matchedMap;
|
||
}
|
||
|
||
/**
|
||
* 新增波次策略。
|
||
*
|
||
* 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);
|
||
}
|
||
}
|
||
|
||
const strategyCacheKey = `${WAVE_STRATEGY_LIST_CACHE_KEY_PREFIX}${normalizedWarehouseId}`;
|
||
if (this.app && typeof this.app.delCacheAsync === 'function') {
|
||
await this.app.delCacheAsync(strategyCacheKey);
|
||
} else if (this.app && typeof this.app.setCacheAsync === 'function') {
|
||
await this.app.setCacheAsync(strategyCacheKey, null, 0);
|
||
}
|
||
|
||
setImmediate(() => {
|
||
this.submitWaveStrategyQuickScanForWarehouse(normalizedWarehouseId)
|
||
.then(scanPayload => {
|
||
this.ctx.logger.info('[wave.bumpWaveStrategyVersionAndInvalidateCache] 异步触发全量扫描成功', {
|
||
warehouseId: normalizedWarehouseId,
|
||
taskId: String(scanPayload && scanPayload.task_id || '').trim(),
|
||
state: String(scanPayload && scanPayload.state || '').trim(),
|
||
});
|
||
})
|
||
.catch(error => {
|
||
this.ctx.logger.warn('[wave.bumpWaveStrategyVersionAndInvalidateCache] 异步触发全量扫描失败,不影响主流程', {
|
||
warehouseId: normalizedWarehouseId,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
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;
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'wave_prefix')) {
|
||
const wavePrefix = String(requestData.wave_prefix || '').trim().slice(0, 5);
|
||
payload.wave_prefix = wavePrefix || null;
|
||
}
|
||
payload.strategy_type = this.normalizeRequiredPositiveInteger(requestData.strategy_type, 'strategy_type');
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'batch_mode')) {
|
||
payload.batch_mode = this.normalizePositiveInteger(requestData.batch_mode, 'batch_mode');
|
||
} else if (payload.strategy_type === 2) {
|
||
payload.batch_mode = 0;
|
||
} else {
|
||
throw new Error('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, 'wave_prefix')) {
|
||
const wavePrefix = String(requestData.wave_prefix || '').trim().slice(0, 5);
|
||
payload.wave_prefix = wavePrefix || null;
|
||
}
|
||
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.normalizePositiveInteger(requestData.batch_mode, 'batch_mode');
|
||
} else if (payload.strategy_type === 2) {
|
||
payload.batch_mode = 0;
|
||
}
|
||
}
|
||
|
||
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');
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'batch_max_orders')) {
|
||
const rawBatchMaxOrders = requestData.batch_max_orders;
|
||
if (rawBatchMaxOrders === null || rawBatchMaxOrders === '') {
|
||
payload.batch_max_orders = null;
|
||
} else {
|
||
payload.batch_max_orders = this.normalizePositiveInteger(rawBatchMaxOrders, 'batch_max_orders');
|
||
}
|
||
}
|
||
const resolvedStrategyType = Object.prototype.hasOwnProperty.call(payload, 'strategy_type')
|
||
? payload.strategy_type
|
||
: Object.prototype.hasOwnProperty.call(requestData, 'strategy_type')
|
||
? this.normalizeRequiredPositiveInteger(requestData.strategy_type, 'strategy_type')
|
||
: null;
|
||
if (resolvedStrategyType === 2) {
|
||
payload.batch_max_orders = 0;
|
||
}
|
||
const resolvedBatchMode = Object.prototype.hasOwnProperty.call(payload, 'batch_mode')
|
||
? payload.batch_mode
|
||
: Object.prototype.hasOwnProperty.call(requestData, 'batch_mode')
|
||
? this.normalizePositiveInteger(requestData.batch_mode, 'batch_mode')
|
||
: null;
|
||
if (resolvedBatchMode === 2) {
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'batch_max_skus')) {
|
||
const rawBatchMaxSkus = requestData.batch_max_skus;
|
||
if (rawBatchMaxSkus === null || rawBatchMaxSkus === '') {
|
||
payload.batch_max_skus = null;
|
||
} else {
|
||
payload.batch_max_skus = this.normalizePositiveInteger(rawBatchMaxSkus, 'batch_max_skus');
|
||
}
|
||
}
|
||
} else {
|
||
payload.batch_max_skus = 0;
|
||
}
|
||
if (resolvedStrategyType !== null && resolvedStrategyType !== 2) {
|
||
payload.group_batch_max_orders = 0;
|
||
} else if (resolvedStrategyType === 2) {
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'group_batch_max_orders')) {
|
||
const rawGroupBatchMaxOrders = requestData.group_batch_max_orders;
|
||
if (rawGroupBatchMaxOrders === null || rawGroupBatchMaxOrders === '') {
|
||
payload.group_batch_max_orders = null;
|
||
} else {
|
||
payload.group_batch_max_orders = this.normalizePositiveInteger(rawGroupBatchMaxOrders, 'group_batch_max_orders');
|
||
}
|
||
}
|
||
} else if (Object.prototype.hasOwnProperty.call(requestData, 'group_batch_max_orders')) {
|
||
const rawGroupBatchMaxOrders = requestData.group_batch_max_orders;
|
||
if (rawGroupBatchMaxOrders === null || rawGroupBatchMaxOrders === '') {
|
||
payload.group_batch_max_orders = null;
|
||
} else {
|
||
payload.group_batch_max_orders = this.normalizePositiveInteger(rawGroupBatchMaxOrders, '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')) {
|
||
const list = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_provinces);
|
||
payload.allowed_provinces = list.length > 0 ? list : null;
|
||
} else if (mode === 'update') {
|
||
payload.allowed_provinces = null;
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_platforms')) {
|
||
const list = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_platforms, false);
|
||
payload.allowed_platforms = list.length > 0 ? list : null;
|
||
} else if (mode === 'update') {
|
||
payload.allowed_platforms = null;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_owners')) {
|
||
const list = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_owners);
|
||
if (list.length > 0) {
|
||
await this.validateWaveStrategyAllowedOwners(list, warehouseId);
|
||
}
|
||
payload.allowed_owners = list.length > 0 ? list : null;
|
||
} else if (mode === 'update') {
|
||
payload.allowed_owners = null;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(requestData, 'allowed_expresses')) {
|
||
const list = this.normalizeWaveStrategyQuickScanStringList(requestData.allowed_expresses, false);
|
||
if (list.length > 0) {
|
||
await this.validateWaveStrategyAllowedExpresses(list);
|
||
}
|
||
payload.allowed_expresses = list.length > 0 ? list : null;
|
||
} else if (mode === 'update') {
|
||
payload.allowed_expresses = null;
|
||
}
|
||
|
||
await this.applyWaveStrategyMaxSameStructureConstraint(payload, warehouseId);
|
||
|
||
delete payload.warehouse_id;
|
||
delete payload.creator;
|
||
delete payload.creator_name;
|
||
|
||
return payload;
|
||
}
|
||
|
||
/**
|
||
* 归一化波次策略波次前缀。
|
||
*
|
||
* 规则:
|
||
* 1. 允许为空字符串(表示回退仓库前缀);
|
||
* 2. 非空时统一转大写;
|
||
* 3. 非空时仅允许 A-Z0-9,长度 1-5。
|
||
*
|
||
* @param {*} rawWavePrefix 原始波次前缀入参。
|
||
* @return {string} 归一化后的波次前缀。
|
||
*/
|
||
normalizeWaveStrategyWavePrefix(rawWavePrefix) {
|
||
if (rawWavePrefix === undefined || rawWavePrefix === null) {
|
||
return '';
|
||
}
|
||
|
||
const normalizedWavePrefix = String(rawWavePrefix).trim()
|
||
.toUpperCase();
|
||
if (!normalizedWavePrefix) {
|
||
return '';
|
||
}
|
||
|
||
if (normalizedWavePrefix.length < 1 || normalizedWavePrefix.length > 5) {
|
||
throw new Error('wave_prefix 非空时长度必须为 1-5 个字符');
|
||
}
|
||
|
||
if (!/^[A-Z0-9]+$/.test(normalizedWavePrefix)) {
|
||
throw new Error('wave_prefix 非空时仅支持 A-Z0-9');
|
||
}
|
||
|
||
return normalizedWavePrefix;
|
||
}
|
||
|
||
/**
|
||
* 解析策略抓取建波使用的前缀(策略优先,仓库前缀兜底)。
|
||
*
|
||
* @param {Object} params 解析参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {number|string} params.strategyType 策略类型(1-散单,2-团购)。
|
||
* @param {Object} [params.strategyRow={}] 策略行。
|
||
* @return {Promise<{ wavePrefix: string, source: string }>} 前缀及来源。
|
||
*/
|
||
async resolveWaveStrategyFetchWavePrefix(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const strategyType = Number(params.strategyType || 0);
|
||
const strategyRow = this.isPlainObject(params.strategyRow) ? params.strategyRow : {};
|
||
const strategyWavePrefix = this.normalizeWaveStrategyWavePrefix(strategyRow.wave_prefix);
|
||
|
||
if (strategyWavePrefix) {
|
||
return {
|
||
wavePrefix: strategyWavePrefix,
|
||
source: 'strategy',
|
||
};
|
||
}
|
||
|
||
const warehouseWavePrefix = strategyType === 2
|
||
? await this.getGroupWavePrefix(warehouseId)
|
||
: await this.getSingleFetchByIdsWavePrefix(warehouseId);
|
||
|
||
return {
|
||
wavePrefix: String(warehouseWavePrefix || '').trim() || (strategyType === 2 ? 'B' : 'A'),
|
||
source: 'warehouse_fallback',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 按字段补丁方式归一化波次策略正整数参数。
|
||
*
|
||
* @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()).filter(Boolean)
|
||
: [];
|
||
if (normalizedExpresses.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const availableExpressSet = await this.getWaveStrategyAvailableExpressSet();
|
||
const availableLowerSet = new Set([ ...availableExpressSet ].map(s => s.toLowerCase()));
|
||
const illegalExpresses = normalizedExpresses.filter(item => !availableLowerSet.has(String(item).toLowerCase()));
|
||
|
||
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,
|
||
warehouse_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 : {};
|
||
|
||
// normalizeOrderListItem 已将 lock_status 归一化为 Y/N(none→N,其余→Y),
|
||
// 这里兼容归一化值(Y/N)与原始值(none/warehouse/store),避免把 N 误判为已锁定。
|
||
const lockStatus = String(normalizedOrderRow.lock_status || '').trim();
|
||
const isLocked = lockStatus === 'Y'
|
||
|| (lockStatus !== '' && lockStatus !== 'N' && lockStatus !== 'none');
|
||
|
||
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,
|
||
items_weight: normalizedOrderRow.items_weight != null ? Number(normalizedOrderRow.items_weight) : null,
|
||
weight_type: this.formatWeightTypeLabel(normalizedOrderRow.weight_type),
|
||
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 || ''),
|
||
wave_index: Number(normalizedOrderRow.wave_index || 0),
|
||
excluded_reason: isLocked
|
||
? WAVE_STRATEGY_FALLBACK_EXCLUDED_REASON_LABELS.locked
|
||
: normalizedOrderRow.intercept_status !== 'none'
|
||
? WAVE_STRATEGY_FALLBACK_EXCLUDED_REASON_LABELS.intercepted
|
||
: normalizedOrderRow.print_status === 'fin'
|
||
? WAVE_STRATEGY_FALLBACK_EXCLUDED_REASON_LABELS.printed
|
||
: WAVE_STRATEGY_FALLBACK_EXCLUDED_REASON_LABELS.no_match,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 查询兜底不符合波次策略的订单列表(含已完全打印被排除的订单)。
|
||
*
|
||
* 查询条件:step != 0 且 wave_id = 0,且满足以下任一条件:
|
||
* - wave_scan_result = 2(未匹配任何波次策略)
|
||
* - print_status = 'fin'(已完全打印,被策略抓取阶段排除)
|
||
* 在当前页订单上增补 item_snapshot(格式:商品名称1*数量|商品名称2*数量)。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Object} data.pagination 分页参数。
|
||
* @param {Object} data.where 查询条件。
|
||
* @param {Object} data.sort 排序参数。
|
||
* @return {Promise<Object>} 列表查询结果,每行含 excluded_reason 标记。
|
||
*/
|
||
async waveStrategyFallbackOrderList(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { pagination, where, sort } = requestData;
|
||
const normalizedPagination = this.normalizePagination(pagination || {});
|
||
const { page, pageSize } = normalizedPagination;
|
||
const normalizedWhere = this.normalizeWaveStrategyFallbackOrderListWhere(where);
|
||
const contextWarehouseId = this.getWarehouseId();
|
||
|
||
// 构建基础 WHERE(复用框架 where 解析、快递号虚拟筛选等能力)
|
||
const { where: ctxWhere } = this.prepareWhereContext(
|
||
{ ...requestData, where: normalizedWhere },
|
||
{ specialFieldMap: { quickWhere: { bucket: 'quick' } } }
|
||
);
|
||
const { where: sanitizedWhere, expressNumbers } = this.extractOrderListExpressVirtualFilter(ctxWhere);
|
||
const { where: whereAfterBuyerMessage, buyerMessageHas } = this.extractBuyerMessageHasVirtualFilter(sanitizedWhere);
|
||
const { where: whereAfterStockQuery, stockQuery } = this.extractStockQueryVirtualFilter(whereAfterBuyerMessage);
|
||
const defaultWhere = this.getDefaultWhere('waveStrategyFallbackOrder');
|
||
const mergedWhere = this.mergeWhereObjects(defaultWhere, whereAfterStockQuery);
|
||
let queryWhere = this.buildWhere(mergedWhere, contextWarehouseId, {
|
||
specialFieldMap: { quickWhere: { bucket: 'quick' } },
|
||
});
|
||
|
||
// 处理快递号虚拟筛选
|
||
if (expressNumbers.length > 0) {
|
||
const orderIds = await this.findOrderIdsByExpressNumbers(expressNumbers, contextWarehouseId);
|
||
queryWhere = this.appendOrderIdsFilterToWhere(queryWhere, orderIds);
|
||
}
|
||
|
||
if (buyerMessageHas !== null) {
|
||
const buyerMessageCondition = this.buildBuyerMessageHasCondition(buyerMessageHas);
|
||
queryWhere = this.appendConditionToWhere(queryWhere, buyerMessageCondition);
|
||
}
|
||
|
||
// 处理 stock_query 虚拟筛选
|
||
if (stockQuery) {
|
||
const stockOrderIds = await this.findOrderIdsByStockQuery(stockQuery, 'waveStrategyFallbackOrder', contextWarehouseId);
|
||
queryWhere = this.appendOrderIdsFilterToWhere(queryWhere, stockOrderIds);
|
||
}
|
||
|
||
// 追加 OR 条件:未匹配策略(wave_scan_result=2) 或 已完全打印被排除(print_status='fin')
|
||
const { Sequelize } = this.app;
|
||
queryWhere = {
|
||
[Sequelize.Op.and]: [
|
||
queryWhere,
|
||
{
|
||
[Sequelize.Op.or]: [
|
||
{ wave_scan_result: 2 },
|
||
{ print_status: 'fin' },
|
||
{ lock_status: { [Sequelize.Op.ne]: 'none' } },
|
||
{ intercept_status: { [Sequelize.Op.ne]: 'none' } },
|
||
],
|
||
},
|
||
],
|
||
};
|
||
|
||
// 获取模型并分页查询
|
||
const model = await this.getOrderModel('waveStrategyFallbackOrder', contextWarehouseId);
|
||
const order = this.buildListOrder(sort, 'waveStrategyFallbackOrder');
|
||
const offset = (page - 1) * pageSize;
|
||
|
||
const [ total, sourceList ] = await Promise.all([
|
||
model.count({ where: queryWhere }),
|
||
model.findAll({
|
||
where: queryWhere,
|
||
limit: pageSize,
|
||
offset,
|
||
order,
|
||
raw: true,
|
||
}),
|
||
]);
|
||
|
||
const normalizedList = await this.attachOrderWaveIndex(
|
||
await this.attachOrderExpressNumbers(
|
||
sourceList.map(item => this.normalizeOrderListItem(item))
|
||
)
|
||
);
|
||
|
||
// 回填 item_snapshot
|
||
const orderIds = normalizedList
|
||
.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 totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
|
||
|
||
const list = normalizedList.map(item => {
|
||
const orderId = Number(item && item.id || 0);
|
||
return this.buildWaveStrategyFallbackOrderListItem(item, itemSnapshotMap.get(orderId) || '');
|
||
});
|
||
|
||
return this.success('ok', {
|
||
list,
|
||
pagination: {
|
||
page,
|
||
pageSize,
|
||
total,
|
||
totalPages,
|
||
hasPrevious: page > 1,
|
||
hasNext: page < totalPages,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 解析波次列表的货主名称映射(store_id → 名称)。
|
||
*
|
||
* 货主名称口径与售后/库存列表一致:合约表 wms_store_warehouse.store_remask
|
||
* (货主备注名称,store_id+warehouse_id 维度)优先,无合约或备注为空时回退
|
||
* wms_store.company_name(公司全称)。
|
||
*
|
||
* @param {Object[]} batchRows 波次行数据(含 order_total/owner_distinct_count/owner_named_count/owner_store_id)。
|
||
* @param {number|string} [warehouseId=0] 当前仓库ID。
|
||
* @return {Promise<Map<number, string>>} store_id → 货主名称。
|
||
*/
|
||
async resolveWaveBatchOwnerStoreNameMap(batchRows = [], warehouseId = 0) {
|
||
const nameMap = new Map();
|
||
const ownerStoreIds = [];
|
||
|
||
for (const batch of batchRows) {
|
||
const orderCount = Number(batch && batch.order_total || 0);
|
||
const ownerDistinctCount = Number(batch && batch.owner_distinct_count || 0);
|
||
const ownerNamedCount = Number(batch && batch.owner_named_count || 0);
|
||
const ownerStoreId = Number(batch && batch.owner_store_id || 0);
|
||
if (orderCount > 0 && ownerDistinctCount === 1 && ownerNamedCount === orderCount && ownerStoreId > 0) {
|
||
ownerStoreIds.push(ownerStoreId);
|
||
}
|
||
}
|
||
|
||
const uniqueStoreIds = [ ...new Set(ownerStoreIds) ];
|
||
if (uniqueStoreIds.length === 0) {
|
||
return nameMap;
|
||
}
|
||
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
try {
|
||
// 1. 合约表货主备注名称(store_id + warehouse_id 维度)
|
||
const contractMap = new Map();
|
||
if (normalizedWarehouseId > 0) {
|
||
const contractRows = await this.ctx.model.StoreWarehouse.findAll({
|
||
where: {
|
||
store_id: { [Op.in]: uniqueStoreIds },
|
||
warehouse_id: normalizedWarehouseId,
|
||
},
|
||
attributes: [ 'store_id', 'store_remask' ],
|
||
raw: true,
|
||
});
|
||
for (const row of contractRows) {
|
||
const remask = String(row.store_remask || '').trim();
|
||
if (remask) {
|
||
contractMap.set(Number(row.store_id), remask);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 2. 货主公司全称兜底
|
||
const storeRows = await this.ctx.model.Store.findAll({
|
||
where: { id: { [Op.in]: uniqueStoreIds } },
|
||
attributes: [ 'id', 'company_name' ],
|
||
raw: true,
|
||
});
|
||
for (const row of storeRows) {
|
||
const companyName = String(row.company_name || '').trim();
|
||
if (companyName) {
|
||
nameMap.set(Number(row.id), companyName);
|
||
}
|
||
}
|
||
|
||
// 3. 备注名称覆盖公司全称
|
||
for (const storeId of uniqueStoreIds) {
|
||
if (contractMap.has(storeId)) {
|
||
nameMap.set(storeId, contractMap.get(storeId));
|
||
}
|
||
}
|
||
} catch (error) {
|
||
this.ctx.logger?.warn?.('resolveWaveBatchOwnerStoreNameMap 解析货主名称失败:', error?.message || error);
|
||
}
|
||
|
||
return nameMap;
|
||
}
|
||
|
||
/**
|
||
* 波次列表查询。
|
||
*
|
||
* 默认查询状态为 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 expressAssignmentFilterClause = this.buildBatchListExpressAssignmentFilterClause(whereClause.expressAssignmentStatus);
|
||
const printAssignmentFilterClause = this.buildBatchListPrintAssignmentFilterClause(whereClause.printAssignmentStatus);
|
||
const reviewAssignmentFilterClause = this.buildBatchListReviewAssignmentFilterClause(whereClause.reviewAssignmentStatus);
|
||
const onlyTodo = Number(requestData.only_todo || 0);
|
||
const baseBatchWhereSql = `
|
||
warehouse_id = :warehouseId
|
||
AND wave_status IN (:waveStatusList)
|
||
${whereClause.sql}
|
||
`;
|
||
const storeIdFilter = Array.isArray(whereClause.storeIds) ? whereClause.storeIds : [];
|
||
const ownerFilterJoinSql = storeIdFilter.length > 0 ? `
|
||
INNER JOIN (
|
||
SELECT candidate_wave.wave_id
|
||
FROM (
|
||
SELECT wave_id
|
||
FROM wms_wave_batch
|
||
WHERE ${baseBatchWhereSql}
|
||
) candidate_wave
|
||
INNER JOIN ${orderTableName} od ON od.wave_id = candidate_wave.wave_id
|
||
AND od.store_id IN (:whereStoreIds)
|
||
GROUP BY candidate_wave.wave_id
|
||
) wave_owner_filter ON wave_owner_filter.wave_id = wb.wave_id
|
||
` : '';
|
||
const batchListFromSql = `
|
||
FROM (
|
||
SELECT
|
||
wave_id,
|
||
wave_no,
|
||
wave_type,
|
||
wave_status,
|
||
total_orders,
|
||
processed_orders,
|
||
distinguish_express,
|
||
source,
|
||
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,
|
||
SUM(CASE WHEN od.post_status = 'none' THEN 1 ELSE 0 END) AS post_none_count,
|
||
SUM(CASE WHEN od.post_status = 'fin' THEN 1 ELSE 0 END) AS post_fin_count,
|
||
SUM(CASE WHEN od.post_status = 'error' THEN 1 ELSE 0 END) AS post_error_count,
|
||
SUM(CASE WHEN od.print_status = 'none' THEN 1 ELSE 0 END) AS print_none_count,
|
||
SUM(CASE WHEN od.print_status = 'fin' THEN 1 ELSE 0 END) AS print_fin_count,
|
||
SUM(CASE WHEN od.inspection_status = 'fin' THEN 1 ELSE 0 END) AS review_fin_count,
|
||
SUM(CASE WHEN od.inspection_status = 'error' THEN 1 ELSE 0 END) AS review_error_count,
|
||
SUM(CASE WHEN od.inspection_status NOT IN ('fin', 'error') THEN 1 ELSE 0 END) AS review_none_count,
|
||
SUM(CASE WHEN od.pick_status = 'none' THEN 1 ELSE 0 END) AS pick_none_count,
|
||
SUM(CASE WHEN od.pick_status = 'fin' THEN 1 ELSE 0 END) AS pick_fin_count,
|
||
SUM(CASE WHEN od.pick_status = 'error' THEN 1 ELSE 0 END) AS pick_error_count,
|
||
COUNT(DISTINCT NULLIF(od.store_id, 0)) AS owner_distinct_count,
|
||
MAX(NULLIF(od.store_id, 0)) AS owner_store_id,
|
||
SUM(CASE WHEN NULLIF(od.store_id, 0) IS NOT NULL THEN 1 ELSE 0 END) AS owner_named_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
|
||
${ownerFilterJoinSql}
|
||
LEFT JOIN wms_express e ON e.code = wb.logistics_name
|
||
WHERE 1 = 1
|
||
${storageAssignmentFilterClause.sql}
|
||
${expressAssignmentFilterClause.sql}
|
||
${printAssignmentFilterClause.sql}
|
||
${reviewAssignmentFilterClause.sql}
|
||
${onlyTodo === 1 ? '\n AND COALESCE(wave_order_stats.order_total, 0) - COALESCE(wave_order_stats.review_fin_count, 0) > 0' : ''}
|
||
`;
|
||
|
||
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.source,
|
||
wb.logistics_name AS logistics_code,
|
||
COALESCE(e.name, wb.logistics_name) AS logistics_name,
|
||
wb.item_snapshot_key,
|
||
wb.warehouse_id,
|
||
wb.creator,
|
||
wb.create_time,
|
||
wb.update_time,
|
||
COALESCE(wave_order_stats.order_total, 0) AS order_total,
|
||
COALESCE(wave_order_stats.storage_none_count, 0) AS storage_none_count,
|
||
COALESCE(wave_order_stats.storage_fin_count, 0) AS storage_fin_count,
|
||
COALESCE(wave_order_stats.storage_error_count, 0) AS storage_error_count,
|
||
COALESCE(wave_order_stats.post_none_count, 0) AS post_none_count,
|
||
COALESCE(wave_order_stats.post_fin_count, 0) AS post_fin_count,
|
||
COALESCE(wave_order_stats.post_error_count, 0) AS post_error_count,
|
||
COALESCE(wave_order_stats.print_none_count, 0) AS print_none_count,
|
||
COALESCE(wave_order_stats.print_fin_count, 0) AS print_fin_count,
|
||
COALESCE(wave_order_stats.review_fin_count, 0) AS review_fin_count,
|
||
COALESCE(wave_order_stats.review_error_count, 0) AS review_error_count,
|
||
COALESCE(wave_order_stats.review_none_count, 0) AS review_none_count,
|
||
COALESCE(wave_order_stats.pick_none_count, 0) AS pick_none_count,
|
||
COALESCE(wave_order_stats.pick_fin_count, 0) AS pick_fin_count,
|
||
COALESCE(wave_order_stats.pick_error_count, 0) AS pick_error_count,
|
||
COALESCE(wave_order_stats.owner_distinct_count, 0) AS owner_distinct_count,
|
||
wave_order_stats.owner_store_id,
|
||
COALESCE(wave_order_stats.owner_named_count, 0) AS owner_named_count
|
||
${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,
|
||
...expressAssignmentFilterClause.replacements,
|
||
...printAssignmentFilterClause.replacements,
|
||
...reviewAssignmentFilterClause.replacements,
|
||
...(storeIdFilter.length > 0 ? { whereStoreIds: storeIdFilter } : {}),
|
||
limit: pageSize,
|
||
offset,
|
||
},
|
||
}),
|
||
this.ctx.model.query(countSql, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveStatusList,
|
||
...whereClause.replacements,
|
||
...storageAssignmentFilterClause.replacements,
|
||
...expressAssignmentFilterClause.replacements,
|
||
...printAssignmentFilterClause.replacements,
|
||
...reviewAssignmentFilterClause.replacements,
|
||
...(storeIdFilter.length > 0 ? { whereStoreIds: storeIdFilter } : {}),
|
||
},
|
||
}),
|
||
]);
|
||
|
||
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 ownerStoreNameMap = await this.resolveWaveBatchOwnerStoreNameMap(rawList, warehouseId);
|
||
|
||
const list = rawList.map(batch => {
|
||
const waveId = Number(batch && batch.wave_id || 0);
|
||
const orderCount = Number(batch && batch.order_total || 0);
|
||
const storageNoneCount = Number(batch && batch.storage_none_count || 0);
|
||
const storageFinCount = Number(batch && batch.storage_fin_count || 0);
|
||
const storageErrorCount = Number(batch && batch.storage_error_count || 0);
|
||
const expressNoneCount = Number(batch && batch.post_none_count || 0);
|
||
const expressFinCount = Number(batch && batch.post_fin_count || 0);
|
||
const expressErrorCount = Number(batch && batch.post_error_count || 0);
|
||
const printNoneCount = Number(batch && batch.print_none_count || 0);
|
||
const printFinCount = Number(batch && batch.print_fin_count || 0);
|
||
const pickNoneCount = Number(batch && batch.pick_none_count || 0);
|
||
const pickFinCount = Number(batch && batch.pick_fin_count || 0);
|
||
const pickErrorCount = Number(batch && batch.pick_error_count || 0);
|
||
const reviewFinCount = Number(batch && batch.review_fin_count || 0);
|
||
const reviewErrorCount = Number(batch && batch.review_error_count || 0);
|
||
const unreviewedOrderCount = orderCount - reviewFinCount;
|
||
const ownerDistinctCount = Number(batch && batch.owner_distinct_count || 0);
|
||
const ownerNamedCount = Number(batch && batch.owner_named_count || 0);
|
||
const ownerStoreId = Number(batch && batch.owner_store_id || 0);
|
||
|
||
// 货主展示:仅当所有订单均存在货主(store_id)且货主唯一时返回货主名称,否则返回“混合”。
|
||
const ownerName = orderCount > 0
|
||
&& ownerDistinctCount === 1
|
||
&& ownerNamedCount === orderCount
|
||
&& ownerStoreId > 0
|
||
? (ownerStoreNameMap.get(ownerStoreId) || '')
|
||
: '混合';
|
||
|
||
// 复核状态判定:error 统一归入未复核
|
||
let reviewAssignmentStatus;
|
||
if (reviewErrorCount > 0 || orderCount === 0 || reviewFinCount === 0) {
|
||
reviewAssignmentStatus = 'unreviewed';
|
||
} else if (reviewFinCount === orderCount) {
|
||
reviewAssignmentStatus = 'reviewed';
|
||
} else {
|
||
reviewAssignmentStatus = 'partially_reviewed';
|
||
}
|
||
|
||
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),
|
||
source: Number(batch && batch.source || 0),
|
||
logistics_code: String(batch && batch.logistics_code || '').trim(),
|
||
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: '已打印',
|
||
}),
|
||
pick_assignment_status: this.resolveAssignmentStatus(orderCount, pickNoneCount, pickFinCount, pickErrorCount, {
|
||
none: '未拣货',
|
||
partial: '部分拣货',
|
||
finished: '已拣货',
|
||
error: '拣货异常',
|
||
}),
|
||
review_assignment_status: reviewAssignmentStatus,
|
||
unreviewed_order_count: unreviewedOrderCount,
|
||
store_name: ownerName,
|
||
};
|
||
});
|
||
|
||
return this.success('ok', {
|
||
list,
|
||
pagination: {
|
||
page,
|
||
pageSize,
|
||
total,
|
||
totalPages,
|
||
hasPrevious: page > 1,
|
||
hasNext: page < totalPages,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 拣货任务列表查询。
|
||
*
|
||
* 基于 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>} 列表与分页结果;每项 list 元素包含 wave_list 数组(wave_id / wave_no / box_no / status / bind_time / pick_time)。
|
||
*/
|
||
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.wave_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,
|
||
c.cart_name AS cart_name,
|
||
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
|
||
LEFT JOIN wms_pick_cart c ON c.id = t.current_cart_id AND c.warehouse_id = t.warehouse_id
|
||
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);
|
||
|
||
// 批量查询 wave_list:收集任务ID,从关联表获取波次详情
|
||
const taskIds = sourceList
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0);
|
||
|
||
const taskWaveMap = new Map();
|
||
if (taskIds.length > 0) {
|
||
const taskWaveRows = await this.ctx.model.query(`
|
||
SELECT
|
||
ptw.task_id,
|
||
ptw.wave_id,
|
||
ptw.wave_no,
|
||
ptw.box_no,
|
||
ptw.status,
|
||
ptw.bind_time,
|
||
ptw.pick_time
|
||
FROM wms_wave_pick_task_wave ptw
|
||
WHERE ptw.task_id IN (:taskIds)
|
||
AND ptw.warehouse_id = :warehouseId
|
||
ORDER BY ptw.id ASC
|
||
`, {
|
||
replacements: { taskIds, warehouseId },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
const normalizedTaskWaveRows = Array.isArray(taskWaveRows) ? taskWaveRows : [];
|
||
for (const row of normalizedTaskWaveRows) {
|
||
const taskId = Number(row && row.task_id || 0);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
continue;
|
||
}
|
||
if (!taskWaveMap.has(taskId)) {
|
||
taskWaveMap.set(taskId, []);
|
||
}
|
||
taskWaveMap.get(taskId).push({
|
||
wave_id: Number(row && row.wave_id || 0),
|
||
wave_no: String(row && row.wave_no || '').trim(),
|
||
box_no: Number(row && row.box_no || 0),
|
||
status: Number(row && row.status || 0),
|
||
bind_time: row && row.bind_time || null,
|
||
pick_time: row && row.pick_time || null,
|
||
});
|
||
}
|
||
}
|
||
|
||
// 回退:对于 wms_wave_pick_task_wave 无记录的任务,
|
||
// 尝试从主表 wave_id / wms_wave_batch 查询波次信息。
|
||
// 兼容场景:散单旧数据未写入关联表、已取消任务关联记录被删除等。
|
||
const missingWaveTaskIds = sourceList
|
||
.map(item => {
|
||
const taskId = Number(item && item.id || 0);
|
||
return Number.isInteger(taskId) && taskId > 0 && !taskWaveMap.has(taskId)
|
||
? { taskId, waveId: Number(item && item.wave_id || 0) }
|
||
: null;
|
||
})
|
||
.filter(Boolean);
|
||
|
||
if (missingWaveTaskIds.length > 0) {
|
||
// 优先走 wms_wave_batch 回退(主表 wave_id 有值时)
|
||
const batchFallbackIds = missingWaveTaskIds.filter(m => m.waveId > 0);
|
||
if (batchFallbackIds.length > 0) {
|
||
const fallbackWaveIds = [ ...new Set(batchFallbackIds.map(m => m.waveId)) ];
|
||
const fallbackWaveRows = await this.ctx.model.query(`
|
||
SELECT
|
||
wave_id,
|
||
wave_no
|
||
FROM wms_wave_batch
|
||
WHERE wave_id IN (:waveIds)
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: { waveIds: fallbackWaveIds, warehouseId },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
const waveNoMap = new Map();
|
||
const normalizedFallbackRows = Array.isArray(fallbackWaveRows) ? fallbackWaveRows : [];
|
||
for (const row of normalizedFallbackRows) {
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
if (!Number.isInteger(waveId) || waveId <= 0) {
|
||
continue;
|
||
}
|
||
waveNoMap.set(waveId, String(row && row.wave_no || '').trim());
|
||
}
|
||
|
||
for (const { taskId, waveId } of batchFallbackIds) {
|
||
const waveNo = waveNoMap.get(waveId) || '';
|
||
taskWaveMap.set(taskId, [{
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
box_no: 0,
|
||
status: 0,
|
||
bind_time: null,
|
||
pick_time: null,
|
||
}]);
|
||
}
|
||
}
|
||
|
||
// 剩余仍未回退到的任务(wave_id 为空或 wms_wave_batch 也无记录),
|
||
// 检查其 batch_no(散单模式下冗余了 wave_no)
|
||
const remainingFallbackTaskIds = missingWaveTaskIds
|
||
.filter(m => !taskWaveMap.has(m.taskId))
|
||
.map(m => m.taskId);
|
||
|
||
if (remainingFallbackTaskIds.length > 0) {
|
||
for (const taskId of remainingFallbackTaskIds) {
|
||
const item = sourceList.find(s => Number(s && s.id || 0) === taskId);
|
||
const batchNo = String(item && item.batch_no || '').trim();
|
||
if (batchNo) {
|
||
taskWaveMap.set(taskId, [{
|
||
wave_id: 0,
|
||
wave_no: batchNo,
|
||
box_no: 0,
|
||
status: 0,
|
||
bind_time: null,
|
||
pick_time: null,
|
||
}]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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(),
|
||
cart_name: String(item && item.cart_name || '').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,
|
||
wave_list: taskWaveMap.get(Number(item && item.id || 0)) || [],
|
||
}));
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量解除波次任务提交接口。
|
||
*
|
||
* 仅处理当前登录仓库下的波次与订单,提交后异步执行。
|
||
*
|
||
* @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 activeTaskWaves = await this.ctx.model.query(
|
||
`SELECT ptw.wave_id
|
||
FROM wms_wave_pick_task_wave ptw
|
||
INNER JOIN wms_wave_pick_task pt ON pt.id = ptw.task_id
|
||
WHERE ptw.wave_id IN (:waveIds)
|
||
AND pt.status IN (0, 1)
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveIds: normalizedWaveIds },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
if (activeTaskWaves.length > 0) {
|
||
throw new Error('波次属于活动拣货任务,请通过任务取消接口处理');
|
||
}
|
||
|
||
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: '批量解除波次任务已存在,请勿重复提交。',
|
||
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: '批量解除波次任务已提交。',
|
||
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: '批量分配快递任务已存在,请勿重复提交。',
|
||
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: '批量分配快递任务已提交。',
|
||
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: '批量分配储位任务已存在,请勿重复提交。',
|
||
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: '批量分配储位任务已提交。',
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* 按仓库提交波次策略快速扫描异步任务。
|
||
*
|
||
* 同一仓库同一时刻仅允许一个任务运行,若命中运行中任务则直接复用已有任务。
|
||
*
|
||
* @param {number|string} [warehouseId=0] 仓库ID,未传时优先使用上下文仓库ID。
|
||
* @param {Object} [options={}] 提交选项。
|
||
* @param {Array<number|string>|number|string} [options.orderIds] 可选订单ID数组。
|
||
* @param {boolean} [options.wait=false] 是否等待任务执行完成后再返回最终进度快照。
|
||
* @return {Promise<Object>} 任务受理结果(plain object)。
|
||
*/
|
||
async submitWaveStrategyQuickScanForWarehouse(warehouseId = 0, options = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
const normalizedOptions = this.isPlainObject(options) ? options : {};
|
||
const orderIds = this.normalizeIdsInput(normalizedOptions.orderIds);
|
||
const wait = this.normalizeBoolean(normalizedOptions.wait, false);
|
||
const forceRescan = this.normalizeBoolean(normalizedOptions.forceRescan, false);
|
||
|
||
const runningTask = await this.getWaveStrategyQuickScanWarehouseLock(normalizedWarehouseId);
|
||
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 {
|
||
task_id: existingTaskId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
state: existingState,
|
||
message: '已有快速扫描任务在运行中。请稍后重试或查询现有任务进度。',
|
||
accepted_at: runningTask.accepted_at || existingProgress && existingProgress.accepted_at || new Date().toISOString(),
|
||
};
|
||
}
|
||
|
||
await this.clearWaveStrategyQuickScanWarehouseLock(normalizedWarehouseId, existingTaskId);
|
||
}
|
||
|
||
const taskId = this.generateWaveStrategyQuickScanTaskId(normalizedWarehouseId);
|
||
const acceptedAt = new Date().toISOString();
|
||
|
||
await this.setWaveStrategyQuickScanTaskProgress(taskId, 'submitted', {
|
||
warehouse_id: normalizedWarehouseId,
|
||
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,
|
||
...(orderIds.length > 0 ? { order_ids: orderIds } : {}),
|
||
error: '',
|
||
error_code: '',
|
||
result: null,
|
||
...(forceRescan ? { force_rescan: true } : {}),
|
||
});
|
||
|
||
await this.setWaveStrategyQuickScanWarehouseLock(normalizedWarehouseId, taskId, {
|
||
state: 'submitted',
|
||
accepted_at: acceptedAt,
|
||
});
|
||
|
||
if (wait) {
|
||
await this.runWaveStrategyQuickScanTask({
|
||
taskId,
|
||
warehouseId: normalizedWarehouseId,
|
||
...(orderIds.length > 0 ? { orderIds } : {}),
|
||
...(forceRescan ? { forceRescan } : {}),
|
||
});
|
||
|
||
const finalProgress = await this.getWaveStrategyQuickScanTaskProgress(taskId) || {};
|
||
return {
|
||
...finalProgress,
|
||
task_id: taskId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
accepted_at: acceptedAt,
|
||
};
|
||
}
|
||
|
||
setImmediate(() => {
|
||
this.runWaveStrategyQuickScanTask({
|
||
taskId,
|
||
warehouseId: normalizedWarehouseId,
|
||
...(orderIds.length > 0 ? { orderIds } : {}),
|
||
...(forceRescan ? { forceRescan } : {}),
|
||
}).catch(error => {
|
||
this.ctx.logger.error('[wave.waveStrategyQuickScan] 后台任务异常', {
|
||
taskId,
|
||
warehouseId: normalizedWarehouseId,
|
||
error: error && error.message ? error.message : error,
|
||
stack: error && error.stack ? error.stack : '',
|
||
});
|
||
});
|
||
});
|
||
|
||
return {
|
||
task_id: taskId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
state: 'submitted',
|
||
message: '快速扫描任务已提交。',
|
||
accepted_at: acceptedAt,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 提交波次策略快速扫描异步任务。
|
||
*
|
||
* 同一仓库同一时刻仅允许一个任务运行,若命中运行中任务则直接返回已有 task_id。
|
||
*
|
||
* @return {Promise<Object>} 任务受理结果。
|
||
*/
|
||
async waveStrategyQuickScan() {
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const submitPayload = await this.submitWaveStrategyQuickScanForWarehouse(contextWarehouseId);
|
||
|
||
return this.success('ok', {
|
||
status: 'success',
|
||
...submitPayload,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 查询波次策略快速扫描任务进度。
|
||
*
|
||
* @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),
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 构建快速扫描订单查询条件。
|
||
*
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {number} strategyVersion 当前策略版本号。
|
||
* @param {Array<number|string>} [orderIds=[]] 限定扫描订单ID数组。
|
||
* @param {boolean} [forceRescan=false] 是否强制全量重扫(忽略版本号条件)。
|
||
* @return {Object} 订单查询 where 条件。
|
||
*/
|
||
buildWaveStrategyQuickScanOrderWhere(warehouseId, strategyVersion, orderIds = [], forceRescan = false) {
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
const where = {
|
||
warehouse_id: warehouseId,
|
||
step: { [Op.ne]: 0 },
|
||
wave_id: 0,
|
||
intercept_status: 'none',
|
||
lock_status: 'none',
|
||
print_status: { [Op.ne]: 'fin' },
|
||
};
|
||
|
||
if (!forceRescan) {
|
||
where[Op.or] = [
|
||
{ wave_strategy_version: { [Op.ne]: strategyVersion } },
|
||
{ wave_strategy_version: { [Op.is]: null } },
|
||
];
|
||
}
|
||
|
||
if (normalizedOrderIds.length > 0) {
|
||
where.id = {
|
||
[Op.in]: normalizedOrderIds,
|
||
};
|
||
}
|
||
|
||
return where;
|
||
}
|
||
|
||
/**
|
||
* 获取快速扫描可用策略行(带缓存)。
|
||
*
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Array<Object>>} 策略原始行数组。
|
||
*/
|
||
async getWaveStrategyQuickScanStrategyRows(warehouseId) {
|
||
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 strategyCacheKey = `${WAVE_STRATEGY_LIST_CACHE_KEY_PREFIX}${warehouseId}`;
|
||
const cachedStrategyRows = this.app && typeof this.app.getCacheAsync === 'function'
|
||
? await this.app.getCacheAsync(strategyCacheKey)
|
||
: null;
|
||
if (Array.isArray(cachedStrategyRows)) {
|
||
return cachedStrategyRows;
|
||
}
|
||
|
||
const strategyRows = await strategyModel.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
status: 1,
|
||
},
|
||
order: [[ 'id', 'ASC' ]],
|
||
raw: true,
|
||
});
|
||
|
||
if (this.app && typeof this.app.setCacheAsync === 'function') {
|
||
await this.app.setCacheAsync(strategyCacheKey, strategyRows, WAVE_STRATEGY_LIST_CACHE_TTL_SECONDS);
|
||
}
|
||
|
||
return strategyRows;
|
||
}
|
||
|
||
/**
|
||
* 获取波次策略快速扫描命中副表模型。
|
||
*
|
||
* @return {Object|null} 命中副表模型;若不可用返回 null。
|
||
*/
|
||
getWaveStrategyQuickScanMatchModel() {
|
||
const modelContext = this.ctx && this.ctx.model;
|
||
if (!modelContext || typeof modelContext !== 'object') {
|
||
return null;
|
||
}
|
||
|
||
return modelContext.wms_order_wave_strategy_match
|
||
|| modelContext.OrderWaveStrategyMatch
|
||
|| modelContext.WmsOrderWaveStrategyMatch
|
||
|| null;
|
||
}
|
||
|
||
/**
|
||
* 同步快速扫描命中策略到副表(先删后写)。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @param {Array<number|string>|number|string} [orderIds=[]] 扫描范围订单ID。
|
||
* @param {Object} [matchedStrategyIdsByOrder={}] 订单命中策略映射。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async syncWaveStrategyQuickScanMatchedStrategies(warehouseId, orderIds = [], matchedStrategyIdsByOrder = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (normalizedOrderIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const matchModel = this.getWaveStrategyQuickScanMatchModel();
|
||
if (!matchModel || typeof matchModel.destroy !== 'function' || typeof matchModel.bulkCreate !== 'function') {
|
||
throw new Error('波次策略命中副表模型不可用');
|
||
}
|
||
|
||
for (let i = 0; i < normalizedOrderIds.length; i += 500) {
|
||
const orderChunk = normalizedOrderIds.slice(i, i + 500);
|
||
await matchModel.destroy({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
order_id: { [Op.in]: orderChunk },
|
||
},
|
||
});
|
||
}
|
||
|
||
const normalizedMatchedMap = this.isPlainObject(matchedStrategyIdsByOrder)
|
||
? matchedStrategyIdsByOrder
|
||
: {};
|
||
const orderScopeSet = new Set(normalizedOrderIds);
|
||
const dedupeSet = new Set();
|
||
const createTime = this.getCurrentDateTime ? this.getCurrentDateTime() : new Date();
|
||
const rows = [];
|
||
|
||
Object.keys(normalizedMatchedMap).forEach(orderKey => {
|
||
const orderId = Number(orderKey);
|
||
if (!Number.isInteger(orderId) || orderId <= 0 || !orderScopeSet.has(orderId)) {
|
||
return;
|
||
}
|
||
|
||
const strategyIds = Array.isArray(normalizedMatchedMap[orderKey])
|
||
? normalizedMatchedMap[orderKey]
|
||
: [];
|
||
strategyIds.forEach(strategyIdItem => {
|
||
const strategyId = Number(strategyIdItem);
|
||
if (!Number.isInteger(strategyId) || strategyId <= 0) {
|
||
return;
|
||
}
|
||
|
||
const dedupeKey = `${orderId}:${strategyId}`;
|
||
if (dedupeSet.has(dedupeKey)) {
|
||
return;
|
||
}
|
||
dedupeSet.add(dedupeKey);
|
||
|
||
rows.push({
|
||
warehouse_id: normalizedWarehouseId,
|
||
order_id: orderId,
|
||
strategy_id: strategyId,
|
||
create_time: createTime,
|
||
});
|
||
});
|
||
});
|
||
|
||
for (let i = 0; i < rows.length; i += 500) {
|
||
const rowChunk = rows.slice(i, i + 500);
|
||
await matchModel.bulkCreate(rowChunk);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理波次策略快速扫描命中副表过期数据。
|
||
*
|
||
* @param {Object} [options={}] 清理参数。
|
||
* @param {number|string} [options.expireHours=24] 过期小时数。
|
||
* @param {number|string} [options.warehouseId] 可选仓库ID。
|
||
* @return {Promise<number>} 删除条数。
|
||
*/
|
||
async cleanupWaveStrategyQuickScanMatchedStrategies(options = {}) {
|
||
const normalizedOptions = this.isPlainObject(options) ? options : {};
|
||
const expireHoursRaw = Number(normalizedOptions.expireHours);
|
||
const expireHours = Number.isFinite(expireHoursRaw) && expireHoursRaw > 0 ? expireHoursRaw : 24;
|
||
const warehouseId = Number(normalizedOptions.warehouseId || 0);
|
||
const expireAt = new Date(Date.now() - Math.floor(expireHours * 60 * 60 * 1000));
|
||
|
||
const matchModel = this.getWaveStrategyQuickScanMatchModel();
|
||
if (!matchModel || typeof matchModel.destroy !== 'function') {
|
||
throw new Error('波次策略命中副表模型不可用');
|
||
}
|
||
|
||
const where = {
|
||
create_time: {
|
||
[Op.lt]: expireAt,
|
||
},
|
||
};
|
||
|
||
if (Number.isInteger(warehouseId) && warehouseId > 0) {
|
||
where.warehouse_id = warehouseId;
|
||
}
|
||
|
||
const deletedCount = await matchModel.destroy({ where });
|
||
// 清理后重建
|
||
if (Number.isInteger(warehouseId) && warehouseId > 0) {
|
||
setImmediate(() => {
|
||
this.submitWaveStrategyQuickScanForWarehouse(warehouseId).catch(err => {
|
||
this.ctx.logger.warn('[wave.cleanupWaveStrategyQuickScanMatchedStrategies] 清理后自动扫描失败: %s', err.message);
|
||
});
|
||
});
|
||
}
|
||
return Number(deletedCount || 0);
|
||
}
|
||
|
||
/**
|
||
* 按仓库 + 订单ID集合清理波次策略快速扫描命中副表数据。
|
||
*
|
||
* @param {number|string} [warehouseId=0] 仓库ID。
|
||
* @param {Array<number|string>|number|string} [orderIds=[]] 订单ID集合。
|
||
* @return {Promise<number>} 删除条数。
|
||
*/
|
||
async cleanupWaveStrategyQuickScanMatchedStrategiesByOrderIds(warehouseId = 0, orderIds = []) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (normalizedOrderIds.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
const matchModel = this.getWaveStrategyQuickScanMatchModel();
|
||
if (!matchModel || typeof matchModel.destroy !== 'function') {
|
||
throw new Error('波次策略命中副表模型不可用');
|
||
}
|
||
|
||
let totalDeletedCount = 0;
|
||
for (let i = 0; i < normalizedOrderIds.length; i += 500) {
|
||
const orderChunk = normalizedOrderIds.slice(i, i + 500);
|
||
if (orderChunk.length === 0) {
|
||
continue;
|
||
}
|
||
|
||
const deletedCount = await matchModel.destroy({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
order_id: { [Op.in]: orderChunk },
|
||
},
|
||
});
|
||
totalDeletedCount += Number(deletedCount || 0);
|
||
}
|
||
|
||
return totalDeletedCount;
|
||
}
|
||
|
||
/**
|
||
* 异步处理订单变更后的波次策略快速扫描副表清理与触发。
|
||
*
|
||
* @param {number|string} [warehouseId=0] 仓库ID。
|
||
* @param {Array<number|string>|number|string} [orderIds=[]] 订单ID集合。
|
||
* @param {Object} [options={}] 处理选项。
|
||
* @param {boolean} [options.triggerScan=false] 是否触发快速扫描。
|
||
* @param {string} [options.source=''] 调用来源。
|
||
* @return {void} 无返回值。
|
||
*/
|
||
enqueueWaveStrategyQuickScanPostOrderChange(warehouseId = 0, orderIds = [], options = {}) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const normalizedOrderIds = this.normalizeIdsInput(orderIds);
|
||
if (normalizedOrderIds.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const normalizedOptions = this.isPlainObject(options) ? options : {};
|
||
const triggerScan = this.normalizeBoolean(normalizedOptions.triggerScan, false);
|
||
const source = String(normalizedOptions.source || '').trim();
|
||
|
||
setImmediate(() => {
|
||
Promise.resolve()
|
||
.then(async () => {
|
||
const deletedCount = await this.cleanupWaveStrategyQuickScanMatchedStrategiesByOrderIds(
|
||
normalizedWarehouseId,
|
||
normalizedOrderIds
|
||
);
|
||
|
||
if (triggerScan) {
|
||
await this.submitWaveStrategyQuickScanForWarehouse(normalizedWarehouseId, {
|
||
orderIds: normalizedOrderIds,
|
||
});
|
||
}
|
||
|
||
this.ctx.logger.info('[wave.enqueueWaveStrategyQuickScanPostOrderChange] 异步处理完成', {
|
||
warehouseId: normalizedWarehouseId,
|
||
orderCount: normalizedOrderIds.length,
|
||
deletedCount,
|
||
triggerScan,
|
||
source,
|
||
});
|
||
})
|
||
.catch(error => {
|
||
this.ctx.logger.warn('[wave.enqueueWaveStrategyQuickScanPostOrderChange] 异步处理失败,不影响主流程', {
|
||
warehouseId: normalizedWarehouseId,
|
||
orderCount: normalizedOrderIds.length,
|
||
triggerScan,
|
||
source,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 执行快速扫描核心流程。
|
||
*
|
||
* @param {Object} [options={}] 执行参数。
|
||
* @param {number} options.warehouseId 仓库ID。
|
||
* @param {number} options.strategyVersion 当前策略版本。
|
||
* @param {Array<number|string>} [options.orderIds] 可选订单ID数组。
|
||
* @param {string} [options.taskId] 任务ID。
|
||
* @return {Promise<Object>} 扫描执行结果。
|
||
*/
|
||
async executeWaveStrategyQuickScan(options = {}) {
|
||
const normalizedOptions = this.isPlainObject(options) ? options : {};
|
||
const warehouseId = Number(normalizedOptions.warehouseId || 0);
|
||
const strategyVersion = this.normalizeWaveStrategyQuickScanVersion(normalizedOptions.strategyVersion);
|
||
const taskId = String(normalizedOptions.taskId || '').trim();
|
||
const orderIds = this.normalizeIdsInput(normalizedOptions.orderIds);
|
||
const forceRescan = this.normalizeBoolean(normalizedOptions.forceRescan, false);
|
||
|
||
const strategyRows = await this.getWaveStrategyQuickScanStrategyRows(warehouseId);
|
||
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: this.buildWaveStrategyQuickScanOrderWhere(warehouseId, strategyVersion, orderIds, forceRescan),
|
||
raw: true,
|
||
});
|
||
|
||
const scanResult = await runWaveStrategyQuickScanRunner({
|
||
orders: orderRows,
|
||
strategyList,
|
||
getStructureKey: order => this.getWaveStrategyQuickScanStructureKey(order),
|
||
getExpressKey: order => this.getWaveStrategyQuickScanExpressKey(order),
|
||
getMatchedStrategyIds: (order, normalizedStrategyList, context) => this.getWaveStrategyQuickScanMatchedStrategyIds(
|
||
order,
|
||
normalizedStrategyList,
|
||
context
|
||
),
|
||
isOrderMatched: (order, normalizedStrategyList, context) => this.isWaveStrategyQuickScanOrderMatched(
|
||
order,
|
||
normalizedStrategyList,
|
||
context
|
||
),
|
||
onProgress: taskId
|
||
? async payload => {
|
||
const totalOrderCount = Number(payload && payload.totalOrderCount || 0);
|
||
const processedOrderCount = Number(payload && payload.processedOrderCount || 0);
|
||
const matchedOrderCount = Number(payload && payload.matchedOrderCount || 0);
|
||
const unmatchedOrderCount = Number(payload && payload.unmatchedOrderCount || 0);
|
||
|
||
const progressPercent = totalOrderCount > 0
|
||
? Math.min(99, Math.round((processedOrderCount / totalOrderCount) * 100))
|
||
: 0;
|
||
|
||
await this.setWaveStrategyQuickScanTaskProgress(taskId, 'running', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: totalOrderCount,
|
||
processed_order_count: processedOrderCount,
|
||
matched_order_count: matchedOrderCount,
|
||
unmatched_order_count: unmatchedOrderCount,
|
||
progress_percent: progressPercent,
|
||
});
|
||
}
|
||
: null,
|
||
});
|
||
|
||
const matchedOrderIds = this.normalizeIdsInput(scanResult.matchedOrderIds);
|
||
const unmatchedOrderIds = this.normalizeIdsInput(scanResult.unmatchedOrderIds);
|
||
const matchedStrategyIdsByOrder = this.isPlainObject(scanResult.matchedStrategyIdsByOrder)
|
||
? Object.keys(scanResult.matchedStrategyIdsByOrder).reduce((acc, key) => {
|
||
const orderId = Number(key);
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
return acc;
|
||
}
|
||
|
||
const rawStrategyIds = scanResult.matchedStrategyIdsByOrder[key];
|
||
const normalizedStrategyIds = [ ...new Set((Array.isArray(rawStrategyIds) ? rawStrategyIds : [])
|
||
.map(item => Number(item))
|
||
.filter(item => Number.isInteger(item) && item > 0)) ];
|
||
acc[orderId] = normalizedStrategyIds;
|
||
return acc;
|
||
}, {})
|
||
: {};
|
||
const scanScopeOrderIds = orderIds.length > 0
|
||
? orderIds
|
||
: [ ...new Set([ ...matchedOrderIds, ...unmatchedOrderIds ]) ];
|
||
|
||
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,
|
||
});
|
||
await this.syncWaveStrategyQuickScanMatchedStrategies(
|
||
warehouseId,
|
||
scanScopeOrderIds,
|
||
matchedStrategyIdsByOrder
|
||
);
|
||
|
||
return {
|
||
strategyVersion,
|
||
totalOrderCount: Number(scanResult.totalOrderCount || 0),
|
||
processedOrderCount: Number(scanResult.processedOrderCount || 0),
|
||
matchedOrderCount: matchedOrderIds.length,
|
||
unmatchedOrderCount: unmatchedOrderIds.length,
|
||
matchedOrderIds,
|
||
unmatchedOrderIds,
|
||
matchedStrategyIdsByOrder,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 执行波次策略快速扫描后台任务。
|
||
*
|
||
* 扫描范围:当前仓库 + step != 0 + wave_id = 0 + wave_strategy_version != 当前策略版本。
|
||
*
|
||
* @param {Object} [params={}] 任务参数。
|
||
* @param {string} params.taskId 任务ID。
|
||
* @param {number|string} [params.warehouseId] 仓库ID。
|
||
* @param {Array<number|string>} [params.orderIds] 订单ID数组(驼峰写法)。
|
||
* @param {Array<number|string>} [params.order_ids] 订单ID数组(下划线写法)。
|
||
* @param {Array<number|string>} [params.ids] 订单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 normalizedParams = this.isPlainObject(params) ? params : {};
|
||
const rawOrderIds = normalizedParams.orderIds !== undefined
|
||
? normalizedParams.orderIds
|
||
: normalizedParams.order_ids !== undefined
|
||
? normalizedParams.order_ids
|
||
: normalizedParams.ids;
|
||
const orderIds = this.normalizeIdsInput(rawOrderIds);
|
||
const forceRescan = this.normalizeBoolean(
|
||
normalizedParams.forceRescan ?? normalizedParams.force_rescan,
|
||
false
|
||
);
|
||
|
||
const subjectConfig = await this.getWarehouseSubjectConfig(warehouseId);
|
||
const strategyVersion = this.normalizeWaveStrategyQuickScanVersion(
|
||
this.getWarehouseSubjectConfigValue(subjectConfig, 'wave_strategy_version')
|
||
);
|
||
|
||
const scanResult = await this.executeWaveStrategyQuickScan({
|
||
warehouseId,
|
||
strategyVersion,
|
||
orderIds,
|
||
taskId: normalizedTaskId,
|
||
forceRescan,
|
||
});
|
||
|
||
if (scanResult.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 durationMs = Date.now() - startTime;
|
||
await this.setWaveStrategyQuickScanTaskProgress(normalizedTaskId, 'success', {
|
||
warehouse_id: warehouseId,
|
||
total_order_count: scanResult.totalOrderCount,
|
||
processed_order_count: scanResult.processedOrderCount,
|
||
matched_order_count: scanResult.matchedOrderCount,
|
||
unmatched_order_count: scanResult.unmatchedOrderCount,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
strategy_version: strategyVersion,
|
||
total_order_count: scanResult.totalOrderCount,
|
||
processed_order_count: scanResult.processedOrderCount,
|
||
matched_order_count: scanResult.matchedOrderCount,
|
||
unmatched_order_count: scanResult.unmatchedOrderCount,
|
||
matched_order_ids: scanResult.matchedOrderIds,
|
||
unmatched_order_ids: scanResult.unmatchedOrderIds,
|
||
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);
|
||
|
||
// 方案 C:扫描完成后检查是否有新订单需要扫描
|
||
try {
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const subjectConfig = await this.getWarehouseSubjectConfig(warehouseId);
|
||
const currentVersion = this.normalizeWaveStrategyQuickScanVersion(
|
||
this.getWarehouseSubjectConfigValue(subjectConfig, 'wave_strategy_version')
|
||
);
|
||
|
||
const pendingCount = await orderModel.count({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
step: { [Op.ne]: 0 },
|
||
wave_id: 0,
|
||
intercept_status: 'none',
|
||
lock_status: 'none',
|
||
print_status: { [Op.ne]: 'fin' },
|
||
[Op.or]: [
|
||
{ wave_strategy_version: { [Op.ne]: currentVersion } },
|
||
{ wave_strategy_version: { [Op.is]: null } },
|
||
],
|
||
},
|
||
});
|
||
|
||
if (pendingCount > 0) {
|
||
this.ctx.logger.info(
|
||
'[wave.runWaveStrategyQuickScanTask] 检测到遗漏订单,触发新一轮扫描',
|
||
{
|
||
warehouseId,
|
||
previousTaskId: normalizedTaskId,
|
||
pendingCount,
|
||
}
|
||
);
|
||
|
||
setImmediate(() => {
|
||
this.submitWaveStrategyQuickScanForWarehouse(warehouseId).catch(error => {
|
||
this.ctx.logger.warn(
|
||
'[wave.runWaveStrategyQuickScanTask] 触发新一轮扫描失败',
|
||
{
|
||
warehouseId,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
}
|
||
);
|
||
});
|
||
});
|
||
}
|
||
} catch (checkError) {
|
||
this.ctx.logger.warn(
|
||
'[wave.runWaveStrategyQuickScanTask] 遗漏订单检查失败',
|
||
{
|
||
warehouseId,
|
||
taskId: normalizedTaskId,
|
||
error: checkError && checkError.message ? checkError.message : `${checkError}`,
|
||
}
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量更新快速扫描结果。
|
||
*
|
||
* @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 : {};
|
||
const strategyId = Number(normalizedRow.strategy_id || normalizedRow.strategyId || normalizedRow.id || 0);
|
||
return {
|
||
strategy_id: Number.isInteger(strategyId) && strategyId > 0 ? strategyId : null,
|
||
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, false),
|
||
allowed_provinces: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_provinces),
|
||
allowed_platforms: this.normalizeWaveStrategyQuickScanStringList(normalizedRow.allowed_platforms, false),
|
||
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 原始值。
|
||
* @param {boolean} [toLowerCase=true] 是否转为小写,默认 true 保持向后兼容。
|
||
* @return {Array<string>} 归一化字符串数组(去重)。
|
||
*/
|
||
normalizeWaveStrategyQuickScanStringList(value, toLowerCase = true) {
|
||
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 => { const s = String(item || '').trim(); return toLowerCase ? s.toLowerCase() : s; })
|
||
.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。
|
||
*
|
||
* 优先级:sys_logistics_code > logistics_code > logistics_name,与 SQL 中 expressExpr 的 COALESCE 口径保持一致。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @return {string} 快递 key(去首尾空格后结果,空值返回空字符串)。
|
||
*/
|
||
getWaveStrategyQuickScanExpressKey(order = {}) {
|
||
const orderObj = order && typeof order === 'object' ? order : {};
|
||
const candidates = [
|
||
String(orderObj.sys_logistics_code || '').trim(),
|
||
String(orderObj.logistics_code || '').trim(),
|
||
String(orderObj.logistics_name || '').trim(),
|
||
];
|
||
return candidates.find(Boolean) || '';
|
||
}
|
||
|
||
/**
|
||
* 当 require_same_express=1 时,按快递分组候选订单,仅保留最大快递组的订单。
|
||
*
|
||
* 分组 key 使用 getWaveStrategyQuickScanExpressKey(sys_logistics_code > logistics_code > logistics_name),
|
||
* 空 key 的订单不参与筛选(直接丢弃)。
|
||
*
|
||
* @param {Array<Object>} candidateRows 候选订单数组。
|
||
* @return {Array<Object>} 按快递筛选后的候选订单数组(仅含最大快递组)。
|
||
*/
|
||
filterCandidateOrdersByRequireSameExpress(candidateRows = []) {
|
||
const rows = Array.isArray(candidateRows) ? candidateRows : [];
|
||
if (rows.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const expressGroups = new Map();
|
||
for (const row of rows) {
|
||
const expressKey = this.getWaveStrategyQuickScanExpressKey(row);
|
||
if (!expressKey) {
|
||
continue;
|
||
}
|
||
if (!expressGroups.has(expressKey)) {
|
||
expressGroups.set(expressKey, []);
|
||
}
|
||
expressGroups.get(expressKey).push(row);
|
||
}
|
||
|
||
if (expressGroups.size === 0) {
|
||
return [];
|
||
}
|
||
|
||
let maxGroup = [];
|
||
for (const groupOrders of expressGroups.values()) {
|
||
if (groupOrders.length > maxGroup.length) {
|
||
maxGroup = groupOrders;
|
||
}
|
||
}
|
||
|
||
return maxGroup;
|
||
}
|
||
|
||
/**
|
||
* 判断订单是否命中任一快速扫描策略。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @param {Array<Object>} strategyList 策略列表。
|
||
* @param {Object} context 统计上下文。
|
||
* @return {boolean} 是否命中。
|
||
*/
|
||
isWaveStrategyQuickScanOrderMatched(order = {}, strategyList = [], context = {}) {
|
||
const matchedStrategyIds = this.getWaveStrategyQuickScanMatchedStrategyIds(order, strategyList, context);
|
||
return matchedStrategyIds.length > 0;
|
||
}
|
||
|
||
/**
|
||
* 获取订单命中的快速扫描策略ID列表。
|
||
*
|
||
* 全量遍历 strategyList,不提前返回,收集所有命中策略的 strategy_id。
|
||
*
|
||
* @param {Object} order 订单记录。
|
||
* @param {Array<Object>} strategyList 策略列表。
|
||
* @param {Object} [context={}] 统计上下文。
|
||
* @return {Array<number>} 去重后的正整数策略ID列表。
|
||
*/
|
||
getWaveStrategyQuickScanMatchedStrategyIds(order, strategyList, context = {}) {
|
||
const list = Array.isArray(strategyList) ? strategyList : [];
|
||
if (list.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const matchedStrategyIds = [];
|
||
for (const strategy of list) {
|
||
if (!this.isWaveStrategyQuickScanOrderMatchedSingleStrategy(order, strategy, context)) {
|
||
continue;
|
||
}
|
||
|
||
const strategyId = Number(strategy && strategy.strategy_id || 0);
|
||
if (Number.isInteger(strategyId) && strategyId > 0) {
|
||
matchedStrategyIds.push(strategyId);
|
||
}
|
||
}
|
||
|
||
return [ ...new Set(matchedStrategyIds) ];
|
||
}
|
||
|
||
/**
|
||
* 判断订单是否命中单条快速扫描策略。
|
||
*
|
||
* @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 structurePrimaryOwnerMap = context && context.structurePrimaryOwnerMap instanceof Map
|
||
? context.structurePrimaryOwnerMap
|
||
: null;
|
||
|
||
const structureKey = this.getWaveStrategyQuickScanStructureKey(normalizedOrder);
|
||
if (!structureKey) {
|
||
return false;
|
||
}
|
||
|
||
const storeId = String(normalizedOrder.store_id || '').trim().toLowerCase();
|
||
|
||
if (normalizedStrategy.allow_cross_owner === false) {
|
||
if (structurePrimaryOwnerMap instanceof Map) {
|
||
const primaryOwnerStoreId = String(structurePrimaryOwnerMap.get(structureKey) || '').trim().toLowerCase();
|
||
if (!primaryOwnerStoreId || storeId !== primaryOwnerStoreId) {
|
||
return false;
|
||
}
|
||
} else {
|
||
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;
|
||
}
|
||
|
||
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 allowedLower = (normalizedStrategy.allowed_expresses || []).map(s => String(s).toLowerCase());
|
||
const hitExpress = expressCandidates.some(code => allowedLower.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 allowedPlatformsLower = normalizedStrategy.allowed_platforms.map(s => String(s).toLowerCase());
|
||
const hitPlatform = platformCandidates.some(code => allowedPlatformsLower.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', 'intercept_status', 'lock_status' ],
|
||
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 excludedInterceptedOrderIds = [ ...new Set(normalizedOrderRows
|
||
.filter(row => this.isInterceptedOrderStatus(row && row.intercept_status))
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
const excludedLockedOrderIds = [ ...new Set(normalizedOrderRows
|
||
.filter(row => this.isLockedOrderStatus(row && row.lock_status))
|
||
.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;
|
||
}
|
||
|
||
// 拦截流程中的订单不允许分配波次
|
||
if (this.isInterceptedOrderStatus(row && row.intercept_status)) {
|
||
return false;
|
||
}
|
||
|
||
// 已锁定的订单不允许抓取波次
|
||
if (this.isLockedOrderStatus(row && row.lock_status)) {
|
||
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,
|
||
excluded_intercepted_order_ids: excludedInterceptedOrderIds,
|
||
excluded_locked_order_ids: excludedLockedOrderIds,
|
||
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,
|
||
});
|
||
|
||
await orderModel.update({
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
}, {
|
||
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',
|
||
});
|
||
this.enqueueWaveStrategyQuickScanPostOrderChange(warehouseId, grabbedOrderIds, {
|
||
triggerScan: false,
|
||
source: '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,
|
||
excluded_intercepted_order_ids: excludedInterceptedOrderIds,
|
||
excluded_locked_order_ids: excludedLockedOrderIds,
|
||
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 removableRowsForCheck = await orderModel.findAll({
|
||
attributes: [ 'wave_id' ],
|
||
where: {
|
||
id: { [Op.in]: normalizedIds },
|
||
step: { [Op.in]: [ 1, 2, 3 ] },
|
||
wave_id: { [Op.gt]: 0 },
|
||
},
|
||
raw: true,
|
||
});
|
||
const affectedWaveIdsForCheck = [ ...new Set((Array.isArray(removableRowsForCheck) ? removableRowsForCheck : [])
|
||
.map(row => Number(row && row.wave_id || 0))
|
||
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
|
||
if (affectedWaveIdsForCheck.length > 0) {
|
||
const activeTaskWaves = await this.ctx.model.query(
|
||
`SELECT ptw.wave_id
|
||
FROM wms_wave_pick_task_wave ptw
|
||
INNER JOIN wms_wave_pick_task pt ON pt.id = ptw.task_id
|
||
WHERE ptw.wave_id IN (:waveIds)
|
||
AND pt.status IN (0, 1)
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveIds: affectedWaveIdsForCheck },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
if (activeTaskWaves.length > 0) {
|
||
throw new Error('波次属于活动拣货任务,请通过任务取消接口处理');
|
||
}
|
||
}
|
||
|
||
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: '',
|
||
wave_strategy_version: 0,
|
||
wave_scan_result: 0,
|
||
}, {
|
||
where: {
|
||
id: { [Op.in]: removablePendingIds },
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const updatedOrderCount = Number(Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0);
|
||
|
||
// 重建受影响波次的订单索引(wave_index 重新排序),并获取各波次剩余订单数量
|
||
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',
|
||
});
|
||
this.enqueueWaveStrategyQuickScanPostOrderChange(warehouseId, removedOrderIds, {
|
||
triggerScan: true,
|
||
source: '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;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 强制重排指定波次的订单索引(wave_index)。
|
||
*
|
||
* 用于修正历史数据中因各种原因导致的 wave_index 不连续问题。
|
||
* 内部调用 replaceOrderWaveIndexByWaveIds 完成索引重建,并同步更新 wms_wave_batch.total_orders。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Array<number|string>|number|string} [data.wave_ids] 波次ID集合。
|
||
* @param {Array<number|string>|number|string} [data.waveIds] 波次ID集合(驼峰写法)。
|
||
* @return {Promise<Object>} 重排结果,含各波次重排前后的订单数量。
|
||
*/
|
||
async resortWaveIndex(data = {}) {
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const warehouseId = contextWarehouseId;
|
||
const rawWaveIds = data && (
|
||
data.wave_ids !== undefined ? data.wave_ids
|
||
: data.waveIds !== undefined ? data.waveIds
|
||
: data.wave_id !== undefined ? data.wave_id
|
||
: data.waveId !== undefined ? data.waveId
|
||
: null
|
||
);
|
||
const normalizedWaveIds = this.normalizeIdsInput(rawWaveIds);
|
||
if (normalizedWaveIds.length === 0) {
|
||
throw new Error('wave_ids 参数不能为空或格式错误');
|
||
}
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
// 重排前记录各波次每单的 wave_index,用于对比是否实际发生重排
|
||
const beforeRows = await this.ctx.model.query(`
|
||
SELECT wave_id, order_id, wave_index
|
||
FROM wms_order_wave_index
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
ORDER BY wave_id, order_id
|
||
`, {
|
||
replacements: { warehouseId, waveIds: normalizedWaveIds },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const beforeIndexMap = new Map(); // waveId -> Map(orderId -> wave_index)
|
||
const beforeCountMap = new Map();
|
||
for (const row of (Array.isArray(beforeRows) ? beforeRows : [])) {
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
const orderId = Number(row && row.order_id || 0);
|
||
const waveIndex = Number(row && row.wave_index || 0);
|
||
if (!Number.isInteger(waveId) || waveId <= 0) continue;
|
||
if (!beforeIndexMap.has(waveId)) beforeIndexMap.set(waveId, new Map());
|
||
if (Number.isInteger(orderId) && orderId > 0) {
|
||
beforeIndexMap.get(waveId).set(orderId, Number.isInteger(waveIndex) ? waveIndex : 0);
|
||
}
|
||
beforeCountMap.set(waveId, (beforeCountMap.get(waveId) || 0) + 1);
|
||
}
|
||
|
||
// 重建波次索引(内部先删后插,wave_index 从 1 开始连续编号)
|
||
const remainingCountMap = await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: normalizedWaveIds,
|
||
orderModel,
|
||
transaction,
|
||
});
|
||
|
||
// 重排后查询各波次每单的 wave_index,用于对比是否实际发生变化
|
||
const afterRows = await this.ctx.model.query(`
|
||
SELECT wave_id, order_id, wave_index
|
||
FROM wms_order_wave_index
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
ORDER BY wave_id, order_id
|
||
`, {
|
||
replacements: { warehouseId, waveIds: normalizedWaveIds },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const afterIndexMap = new Map(); // waveId -> Map(orderId -> wave_index)
|
||
for (const row of (Array.isArray(afterRows) ? afterRows : [])) {
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
const orderId = Number(row && row.order_id || 0);
|
||
const waveIndex = Number(row && row.wave_index || 0);
|
||
if (!Number.isInteger(waveId) || waveId <= 0) continue;
|
||
if (!afterIndexMap.has(waveId)) afterIndexMap.set(waveId, new Map());
|
||
if (Number.isInteger(orderId) && orderId > 0) {
|
||
afterIndexMap.get(waveId).set(orderId, Number.isInteger(waveIndex) ? waveIndex : 0);
|
||
}
|
||
}
|
||
|
||
// 同步更新 wms_wave_batch.total_orders
|
||
const waveDetails = [];
|
||
for (const waveId of normalizedWaveIds) {
|
||
const remainingCount = Number(remainingCountMap.get(waveId) || 0);
|
||
const beforeCount = Number(beforeCountMap.get(waveId) || 0);
|
||
|
||
if (remainingCount > 0) {
|
||
await this.ctx.model.query(`
|
||
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
|
||
`, {
|
||
replacements: { warehouseId, waveId, remainingCount },
|
||
transaction,
|
||
});
|
||
} else {
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_batch
|
||
SET total_orders = 0,
|
||
processed_orders = 0,
|
||
wave_status = -1,
|
||
update_time = NOW()
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id = :waveId
|
||
`, {
|
||
replacements: { warehouseId, waveId },
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
// 对比每单重排前后的 wave_index,判断是否实际发生变化
|
||
const beforeOrderMap = beforeIndexMap.get(waveId) || new Map();
|
||
const afterOrderMap = afterIndexMap.get(waveId) || new Map();
|
||
const allOrderIds = new Set([ ...beforeOrderMap.keys(), ...afterOrderMap.keys() ]);
|
||
let hasChanged = beforeCount !== remainingCount;
|
||
if (!hasChanged) {
|
||
for (const oid of allOrderIds) {
|
||
if (beforeOrderMap.get(oid) !== afterOrderMap.get(oid)) {
|
||
hasChanged = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
waveDetails.push({
|
||
wave_id: waveId,
|
||
before_index_count: beforeCount,
|
||
after_index_count: remainingCount,
|
||
reordered: hasChanged,
|
||
});
|
||
}
|
||
|
||
await transaction.commit();
|
||
|
||
const totalBefore = waveDetails.reduce((sum, w) => sum + w.before_index_count, 0);
|
||
const totalAfter = waveDetails.reduce((sum, w) => sum + w.after_index_count, 0);
|
||
|
||
return this.success('ok', {
|
||
warehouse_id: warehouseId,
|
||
wave_count: normalizedWaveIds.length,
|
||
total_before_index_count: totalBefore,
|
||
total_after_index_count: totalAfter,
|
||
waves: waveDetails,
|
||
});
|
||
} 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: '批量移除异常订单任务已存在,请勿重复提交。',
|
||
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: '批量移除异常订单任务已提交。',
|
||
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 = [];
|
||
const removedOrderIdSet = new Set();
|
||
|
||
for (const wave of targetWaves) {
|
||
const waveId = Number(wave.wave_id || 0);
|
||
const waveNo = String(wave.wave_no || '').trim() || '未知波次';
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
const affectedOrderRows = await orderModel.findAll({
|
||
attributes: [ 'id', 'wave_id', 'wave_no' ],
|
||
where: {
|
||
wave_id: waveId,
|
||
},
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
const cancelOrderLogItems = (Array.isArray(affectedOrderRows) ? affectedOrderRows : [])
|
||
.map(row => {
|
||
const orderId = Number(row && row.id || 0);
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_CANCEL',
|
||
message: `波次 ${waveNo} 被删除,订单移出波次`,
|
||
};
|
||
})
|
||
.filter(Boolean);
|
||
|
||
const orderUpdateResult = await orderModel.update({
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
wave_strategy_version: 0,
|
||
wave_scan_result: 0,
|
||
}, {
|
||
where: {
|
||
wave_id: waveId,
|
||
},
|
||
transaction,
|
||
});
|
||
const currentAffectedOrderCount = Number(
|
||
Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0
|
||
);
|
||
|
||
const cancelSql = `
|
||
UPDATE wms_wave_batch
|
||
SET wave_status = -1,
|
||
update_time = NOW()
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id = :waveId
|
||
`;
|
||
const cancelResult = await this.ctx.model.query(cancelSql, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveId,
|
||
},
|
||
transaction,
|
||
});
|
||
const cancelMeta = Array.isArray(cancelResult) ? cancelResult[1] : null;
|
||
const currentCanceledWaveCount = Number(
|
||
cancelMeta && (cancelMeta.affectedRows || cancelMeta.affectedCount || cancelMeta.rowCount)
|
||
|| 0
|
||
);
|
||
|
||
await this.deleteOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: [ waveId ],
|
||
transaction,
|
||
});
|
||
|
||
await transaction.commit();
|
||
|
||
await this.batchCreateOrderOperationLogs(cancelOrderLogItems, {
|
||
warehouseId,
|
||
scene: 'batchCancel',
|
||
});
|
||
|
||
const currentRemovedOrderIds = (Array.isArray(affectedOrderRows) ? affectedOrderRows : [])
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0);
|
||
for (const orderId of currentRemovedOrderIds) {
|
||
removedOrderIdSet.add(orderId);
|
||
}
|
||
|
||
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 removedOrderIds = [ ...removedOrderIdSet ].sort((a, b) => a - b);
|
||
this.enqueueWaveStrategyQuickScanPostOrderChange(warehouseId, removedOrderIds, {
|
||
triggerScan: true,
|
||
source: 'batchCancel',
|
||
});
|
||
|
||
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', 'intercept_status', 'lock_status' ],
|
||
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', 'intercept_status', 'lock_status' ],
|
||
where: baseOrderWhere,
|
||
raw: true,
|
||
});
|
||
}
|
||
|
||
this.ctx.logger.info('[wave.batchAllocateExpress] 订单筛选完成', {
|
||
traceId,
|
||
taskId: normalizedTaskId,
|
||
warehouseId,
|
||
waveIds,
|
||
useBusinessKeyColumn,
|
||
matchedOrderCount: Array.isArray(orderRows) ? orderRows.length : 0,
|
||
});
|
||
|
||
const skippedInterceptedOrderIds = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.filter(row => this.isInterceptedOrderStatus(row && row.intercept_status))
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
const skippedInterceptedOrderIdSet = new Set(skippedInterceptedOrderIds);
|
||
if (skippedInterceptedOrderIds.length > 0) {
|
||
this.ctx.logger.info('[wave.batchAllocateExpress] 跳过拦截订单', {
|
||
traceId,
|
||
taskId: normalizedTaskId,
|
||
warehouseId,
|
||
skippedInterceptedOrderIds,
|
||
});
|
||
}
|
||
|
||
const skippedLockedOrderIds = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.filter(row => this.isLockedOrderStatus(row && row.lock_status))
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
const skippedLockedOrderIdSet = new Set(skippedLockedOrderIds);
|
||
if (skippedLockedOrderIds.length > 0) {
|
||
this.ctx.logger.info('[wave.batchAllocateExpress] 跳过锁定订单', {
|
||
traceId,
|
||
taskId: normalizedTaskId,
|
||
warehouseId,
|
||
skippedLockedOrderIds,
|
||
});
|
||
}
|
||
|
||
const normalizedOrders = (Array.isArray(orderRows) ? orderRows : [])
|
||
.map(row => {
|
||
const orderId = Number(row && row.id || 0);
|
||
if (!Number.isInteger(orderId) || orderId <= 0
|
||
|| skippedInterceptedOrderIdSet.has(orderId)
|
||
|| skippedLockedOrderIdSet.has(orderId)) {
|
||
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,
|
||
skippedInterceptedOrderIds,
|
||
skippedLockedOrderIds,
|
||
});
|
||
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,
|
||
skipped_intercepted_order_ids: skippedInterceptedOrderIds,
|
||
skipped_locked_order_ids: skippedLockedOrderIds,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
wave_ids: waveIds,
|
||
allocated_order_count: 0,
|
||
skipped_intercepted_order_ids: skippedInterceptedOrderIds,
|
||
skipped_locked_order_ids: skippedLockedOrderIds,
|
||
duration_ms: durationMs,
|
||
message: skippedInterceptedOrderIds.length > 0 || skippedLockedOrderIds.length > 0
|
||
? `拦截/锁定订单已跳过,未找到可分配快递号的订单(拦截 ${skippedInterceptedOrderIds.length} 单,锁定 ${skippedLockedOrderIds.length} 单)`
|
||
: '未找到可分配快递号的订单',
|
||
},
|
||
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,
|
||
skipped_intercepted_order_ids: skippedInterceptedOrderIds,
|
||
skipped_locked_order_ids: skippedLockedOrderIds,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
wave_ids: waveIds,
|
||
allocated_order_count: normalizedOrders.length,
|
||
skipped_intercepted_order_ids: skippedInterceptedOrderIds,
|
||
skipped_locked_order_ids: skippedLockedOrderIds,
|
||
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', 'lock_status' ],
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
wave_id: {
|
||
[Op.in]: waveIds,
|
||
},
|
||
step: {
|
||
[Op.in]: [ 1, 2, 3 ],
|
||
},
|
||
},
|
||
raw: true,
|
||
});
|
||
|
||
const skippedLockedOrderIdSet = new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.filter(row => this.isLockedOrderStatus(row && row.lock_status))
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0));
|
||
const normalizedOrders = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ]
|
||
.filter(orderId => !skippedLockedOrderIdSet.has(orderId))
|
||
.map(orderId => ({
|
||
order_id: orderId,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
}));
|
||
const normalizedOrderIds = normalizedOrders.map(item => Number(item.order_id || 0)).filter(Boolean);
|
||
|
||
if (normalizedOrderIds.length === 0) {
|
||
const durationMs = Date.now() - startTime;
|
||
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'success', {
|
||
warehouse_id: warehouseId,
|
||
total_wave_count: waveIds.length,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
total_order_count: 0,
|
||
processed_order_count: 0,
|
||
success_order_count: 0,
|
||
failed_order_count: 0,
|
||
affected_order_ids: [],
|
||
affected_order_count: 0,
|
||
allocated_order_ids: [],
|
||
allocated_order_count: 0,
|
||
shortage_order_ids: [],
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
wave_ids: waveIds,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
affected_order_ids: [],
|
||
affected_order_count: 0,
|
||
allocated_order_ids: [],
|
||
allocated_order_count: 0,
|
||
shortage_order_ids: [],
|
||
duration_ms: durationMs,
|
||
message: '未找到可分配储位的订单',
|
||
},
|
||
});
|
||
return;
|
||
}
|
||
|
||
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'running', {
|
||
warehouse_id: warehouseId,
|
||
total_wave_count: waveIds.length,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
total_order_count: normalizedOrderIds.length,
|
||
});
|
||
|
||
const progressCallback = async callbackPayload => {
|
||
const latestProgress = await this.getBatchAllocateStorageTaskProgress(normalizedTaskId);
|
||
const runningProgressPayload = this.buildBatchAllocateStorageRunningProgressPayload(
|
||
callbackPayload,
|
||
latestProgress || {
|
||
total_order_count: normalizedOrderIds.length,
|
||
processed_order_count: 0,
|
||
progress_percent: 0,
|
||
}
|
||
);
|
||
|
||
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'running', {
|
||
warehouse_id: warehouseId,
|
||
total_wave_count: waveIds.length,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
...runningProgressPayload,
|
||
});
|
||
};
|
||
|
||
const pipelineResult = await this.service.systems.orderStorageAllocation.allocateStorage({
|
||
ids: normalizedOrderIds,
|
||
orders: normalizedOrders,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
progress_callback: progressCallback,
|
||
});
|
||
|
||
if (!this.isPlainObject(pipelineResult) || Number(pipelineResult.code) !== 200) {
|
||
throw new Error(String(pipelineResult && pipelineResult.message || '储位分配任务提交失败').trim());
|
||
}
|
||
|
||
const resultData = this.isPlainObject(pipelineResult.data) ? pipelineResult.data : {};
|
||
const pendingOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.pending_order_ids);
|
||
const affectedOrderIds = pendingOrderIds.length > 0
|
||
? pendingOrderIds
|
||
: this.normalizeBatchAllocateStorageOrderIds(normalizedOrderIds);
|
||
const allocatedOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.allocated_order_ids);
|
||
const shortageOrderIds = this.normalizeBatchAllocateStorageOrderIds(resultData.shortage_order_ids);
|
||
const affectedOrderCount = affectedOrderIds.length;
|
||
const successOrderCount = allocatedOrderIds.length;
|
||
const failedOrderCount = shortageOrderIds.length > 0
|
||
? shortageOrderIds.length
|
||
: Math.max(0, affectedOrderCount - successOrderCount);
|
||
const durationMs = Date.now() - startTime;
|
||
|
||
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'success', {
|
||
warehouse_id: warehouseId,
|
||
total_wave_count: waveIds.length,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
total_order_count: affectedOrderCount,
|
||
processed_order_count: affectedOrderCount,
|
||
success_order_count: successOrderCount,
|
||
failed_order_count: failedOrderCount,
|
||
affected_order_ids: affectedOrderIds,
|
||
affected_order_count: affectedOrderCount,
|
||
allocated_order_ids: allocatedOrderIds,
|
||
allocated_order_count: successOrderCount,
|
||
shortage_order_ids: shortageOrderIds,
|
||
progress_percent: 100,
|
||
end_time: Date.now(),
|
||
duration_ms: durationMs,
|
||
result: {
|
||
wave_ids: waveIds,
|
||
business_id: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID,
|
||
business_ids: BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS,
|
||
affected_order_ids: affectedOrderIds,
|
||
affected_order_count: affectedOrderCount,
|
||
allocated_order_ids: allocatedOrderIds,
|
||
allocated_order_count: successOrderCount,
|
||
shortage_order_ids: shortageOrderIds,
|
||
duration_ms: durationMs,
|
||
message: String(pipelineResult && pipelineResult.message || '分配储位任务已提交').trim(),
|
||
},
|
||
});
|
||
} catch (error) {
|
||
await this.setBatchAllocateStorageTaskProgress(normalizedTaskId, 'failed', {
|
||
warehouse_id: warehouseId,
|
||
progress_percent: 0,
|
||
end_time: Date.now(),
|
||
duration_ms: Date.now() - startTime,
|
||
error: error && error.message ? error.message : `${error}`,
|
||
error_code: 'WAVE_BATCH_ALLOCATE_STORAGE_FAILED',
|
||
});
|
||
} finally {
|
||
this.releaseBatchAllocateStorageWarehouseLock(warehouseId, normalizedTaskId);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量将波次状态改为“自动加团中”。
|
||
*
|
||
* 仅处理当前登录仓库下命中的波次状态,不修改订单表 wave_id。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Array<number|string>|number|string} data.ids 波次ID集合。
|
||
* @return {Promise<Object>} 批量更新结果。
|
||
*/
|
||
async batchAutoGrouping(data = {}) {
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const warehouseId = contextWarehouseId;
|
||
const normalizedIds = this.normalizeIdsInput(data && data.ids);
|
||
if (normalizedIds.length === 0) {
|
||
throw new Error('ids 参数不能为空或格式错误');
|
||
}
|
||
|
||
const maxWaveQuantity = await this.getDefaultWaveQuantity(warehouseId);
|
||
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
const querySql = `
|
||
SELECT wave_id, wave_status, total_orders
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:ids)
|
||
`;
|
||
|
||
const queryRows = await this.ctx.model.query(querySql, {
|
||
replacements: {
|
||
warehouseId,
|
||
ids: normalizedIds,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const affectedRows = Array.isArray(queryRows) ? queryRows : [];
|
||
const affectedWaveIds = [ ...new Set(affectedRows
|
||
.map(row => Number(row && row.wave_id || 0))
|
||
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
|
||
|
||
const skippedDetails = [];
|
||
const skippedWaveIds = [];
|
||
const updatableWaveIds = [];
|
||
|
||
for (const row of affectedRows) {
|
||
const waveId = Number(row && row.wave_id || 0);
|
||
if (!Number.isInteger(waveId) || waveId <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const waveStatus = Number(row && row.wave_status || 0);
|
||
const totalOrders = Number(row && row.total_orders || 0);
|
||
|
||
if (waveStatus >= 2) {
|
||
skippedWaveIds.push(waveId);
|
||
skippedDetails.push({
|
||
wave_id: waveId,
|
||
reason: 'printed_or_after_printed',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (totalOrders >= maxWaveQuantity) {
|
||
skippedWaveIds.push(waveId);
|
||
skippedDetails.push({
|
||
wave_id: waveId,
|
||
reason: 'reach_max_wave_quantity',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
updatableWaveIds.push(waveId);
|
||
}
|
||
|
||
if (affectedWaveIds.length === 0) {
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: [],
|
||
skipped_wave_ids: [],
|
||
skipped_wave_count: 0,
|
||
skipped_details: [],
|
||
updated_wave_count: 0,
|
||
});
|
||
}
|
||
|
||
if (updatableWaveIds.length === 0) {
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: affectedWaveIds,
|
||
skipped_wave_ids: skippedWaveIds,
|
||
skipped_wave_count: skippedWaveIds.length,
|
||
skipped_details: skippedDetails,
|
||
updated_wave_count: 0,
|
||
});
|
||
}
|
||
|
||
const updateSql = `
|
||
UPDATE wms_wave_batch
|
||
SET wave_status = 0,
|
||
update_time = NOW()
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
`;
|
||
|
||
const updateResult = await this.ctx.model.query(updateSql, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveIds: updatableWaveIds,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const updateMeta = Array.isArray(updateResult) ? updateResult[1] : null;
|
||
const updatedWaveCount = Number(
|
||
updateMeta && (updateMeta.affectedRows || updateMeta.affectedCount || updateMeta.rowCount)
|
||
|| updatableWaveIds.length
|
||
);
|
||
|
||
await transaction.commit();
|
||
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: affectedWaveIds,
|
||
skipped_wave_ids: skippedWaveIds,
|
||
skipped_wave_count: skippedWaveIds.length,
|
||
skipped_details: skippedDetails,
|
||
updated_wave_count: Number.isInteger(updatedWaveCount) && updatedWaveCount > 0 ? updatedWaveCount : 0,
|
||
});
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量结束“自动加团中”状态。
|
||
*
|
||
* 仅处理当前登录仓库下命中的波次,且仅将 wave_status=0 的波次更新为 1(已就绪)。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {Array<number|string>|number|string} data.ids 波次ID集合。
|
||
* @return {Promise<Object>} 批量结束结果。
|
||
*/
|
||
async batchFinishAutoGrouping(data = {}) {
|
||
const contextWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const warehouseId = contextWarehouseId;
|
||
const normalizedIds = this.normalizeIdsInput(data && data.ids);
|
||
if (normalizedIds.length === 0) {
|
||
throw new Error('ids 参数不能为空或格式错误');
|
||
}
|
||
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
const querySql = `
|
||
SELECT wave_id, wave_status
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:ids)
|
||
`;
|
||
|
||
const queryRows = await this.ctx.model.query(querySql, {
|
||
replacements: {
|
||
warehouseId,
|
||
ids: normalizedIds,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const affectedRows = Array.isArray(queryRows) ? queryRows : [];
|
||
const affectedWaveIds = [ ...new Set(affectedRows
|
||
.map(row => Number(row && row.wave_id || 0))
|
||
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
|
||
|
||
if (affectedWaveIds.length === 0) {
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: [],
|
||
updated_wave_ids: [],
|
||
updated_wave_count: 0,
|
||
});
|
||
}
|
||
|
||
const updatedWaveIds = [ ...new Set(affectedRows
|
||
.filter(row => Number(row && row.wave_status || 0) === 0)
|
||
.map(row => Number(row && row.wave_id || 0))
|
||
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
|
||
|
||
if (updatedWaveIds.length === 0) {
|
||
await transaction.commit();
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: affectedWaveIds,
|
||
updated_wave_ids: [],
|
||
updated_wave_count: 0,
|
||
});
|
||
}
|
||
|
||
// 关闭自动加团前,重建波次订单索引(wave_index 重新排序),确保序号连续
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
await this.replaceOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds: updatedWaveIds,
|
||
orderModel,
|
||
transaction,
|
||
});
|
||
|
||
const updateSql = `
|
||
UPDATE wms_wave_batch
|
||
SET wave_status = 1,
|
||
update_time = NOW()
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
AND wave_status = 0
|
||
`;
|
||
|
||
const updateResult = await this.ctx.model.query(updateSql, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveIds: updatedWaveIds,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const updateMeta = Array.isArray(updateResult) ? updateResult[1] : null;
|
||
const updatedWaveCount = Number(
|
||
updateMeta && (updateMeta.affectedRows || updateMeta.affectedCount || updateMeta.rowCount)
|
||
|| updatedWaveIds.length
|
||
);
|
||
|
||
await transaction.commit();
|
||
|
||
return this.success('ok', {
|
||
ids: normalizedIds,
|
||
affected_wave_ids: affectedWaveIds,
|
||
updated_wave_ids: updatedWaveIds,
|
||
updated_wave_count: Number.isInteger(updatedWaveCount) && updatedWaveCount > 0 ? updatedWaveCount : 0,
|
||
});
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成可追踪的抓取任务ID。
|
||
*
|
||
* @param {number|string} warehouseId 仓库ID。
|
||
* @return {string} 抓取任务ID。
|
||
*/
|
||
generateFetchTaskId(warehouseId = 0) {
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const safeWarehouseId = Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0
|
||
? normalizedWarehouseId
|
||
: 0;
|
||
const waveIdSeed = this.generateWaveId();
|
||
return `wave_fetch_${safeWarehouseId}_${waveIdSeed}`;
|
||
}
|
||
|
||
/**
|
||
* 归一化抓取任务ID。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {string} data.task_id 任务ID(下划线写法)。
|
||
* @param {string} data.taskId 任务ID(驼峰写法)。
|
||
* @return {string} 归一化后的任务ID。
|
||
*/
|
||
normalizeFetchTaskId(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
|
||
}
|
||
|
||
/**
|
||
* 获取抓取任务进度缓存键。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @return {string} 缓存键。
|
||
*/
|
||
getFetchTaskCacheKey(taskId = '') {
|
||
const normalizedTaskId = String(taskId || '').trim();
|
||
if (!normalizedTaskId) {
|
||
return '';
|
||
}
|
||
|
||
return `${FETCH_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
|
||
}
|
||
|
||
/**
|
||
* 写入抓取任务进度缓存。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @param {Object} payload 进度数据。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async setFetchTaskProgress(taskId = '', payload = {}) {
|
||
const cacheKey = this.getFetchTaskCacheKey(taskId);
|
||
if (!cacheKey) {
|
||
return;
|
||
}
|
||
|
||
const safePayload = this.isPlainObject(payload) ? payload : {};
|
||
const progressPayload = {
|
||
...safePayload,
|
||
task_id: String(taskId || '').trim(),
|
||
update_time: Date.now(),
|
||
};
|
||
|
||
try {
|
||
await this.app.setCacheAsync(cacheKey, progressPayload, FETCH_TASK_CACHE_TTL_SECONDS);
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.fetch] 写入任务进度缓存失败: %s', error && error.message ? error.message : error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 读取抓取任务进度缓存。
|
||
*
|
||
* @param {string} taskId 任务ID。
|
||
* @return {Promise<Object|null>} 任务进度缓存。
|
||
*/
|
||
async getFetchTaskProgress(taskId = '') {
|
||
const cacheKey = this.getFetchTaskCacheKey(taskId);
|
||
if (!cacheKey) {
|
||
return null;
|
||
}
|
||
|
||
try {
|
||
const cached = await this.app.getCacheAsync(cacheKey);
|
||
if (!this.isPlainObject(cached)) {
|
||
return null;
|
||
}
|
||
|
||
return cached;
|
||
} catch (error) {
|
||
this.ctx.logger.warn('[wave.fetch] 读取任务进度缓存失败: %s', error && error.message ? error.message : error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询抓取任务进度。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {string} data.task_id 任务ID(下划线写法)。
|
||
* @param {string} data.taskId 任务ID(驼峰写法)。
|
||
* @return {Promise<Object>} 任务进度响应。
|
||
*/
|
||
async fetchTaskProgress(data = {}) {
|
||
const taskId = this.normalizeFetchTaskId(data);
|
||
if (!taskId) {
|
||
return this.fail('task_id 参数不能为空', 400);
|
||
}
|
||
|
||
const cachedProgress = await this.getFetchTaskProgress(taskId);
|
||
|
||
if (!cachedProgress) {
|
||
return this.success('ok', {
|
||
task_id: taskId,
|
||
status: 'not_found',
|
||
});
|
||
}
|
||
|
||
return this.success('ok', {
|
||
task_id: taskId,
|
||
...cachedProgress,
|
||
status: String(cachedProgress.status || 'unknown').trim() || 'unknown',
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 执行异步抓取任务。
|
||
*
|
||
* @param {Object} params 任务参数。
|
||
* @param {string} params.taskId 任务ID。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {number} params.defaultQuantity 默认抓取数量。
|
||
* @param {Array<Object>} params.structures 结构化抓取请求。
|
||
* @param {string} [params.fetchMode='group'] 抓取模式:group|single。
|
||
* @param {number} [params.maxFetchQuantity=0] single 模式最大抓取订单数上限。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async runFetchTask({
|
||
taskId = '',
|
||
warehouseId = 0,
|
||
defaultQuantity = DEFAULT_MAX_WAVE_QUANTITY,
|
||
structures = [],
|
||
fetchMode = 'group',
|
||
maxFetchQuantity = 0,
|
||
} = {}) {
|
||
const normalizedTaskId = String(taskId || '').trim();
|
||
const normalizedWarehouseId = Number(warehouseId || 0);
|
||
const structureList = Array.isArray(structures) ? structures : [];
|
||
const normalizedFetchMode = String(fetchMode || 'group').trim() === 'single' ? 'single' : 'group';
|
||
const normalizedMaxFetchQuantity = Number.isInteger(Number(maxFetchQuantity)) && Number(maxFetchQuantity) > 0
|
||
? Number(maxFetchQuantity)
|
||
: 0;
|
||
|
||
if (!normalizedTaskId) {
|
||
throw new Error('taskId 不能为空');
|
||
}
|
||
|
||
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
throw new Error('warehouseId 参数不合法');
|
||
}
|
||
|
||
if (structureList.length === 0) {
|
||
throw new Error('structures 不能为空');
|
||
}
|
||
|
||
if (normalizedFetchMode === 'single' && normalizedMaxFetchQuantity <= 0) {
|
||
throw new Error('single 模式要求 maxFetchQuantity 为正整数');
|
||
}
|
||
|
||
this.ctx.logger.info('[wave.fetch] 后台任务开始', {
|
||
taskId: normalizedTaskId,
|
||
warehouseId: normalizedWarehouseId,
|
||
structureCount: structureList.length,
|
||
defaultQuantity: Number(defaultQuantity || 0),
|
||
fetchMode: normalizedFetchMode,
|
||
maxFetchQuantity: normalizedMaxFetchQuantity,
|
||
});
|
||
|
||
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 } : {}),
|
||
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 } : {}),
|
||
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: '达到最大抓取上限' } : {}),
|
||
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,
|
||
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 } : {}),
|
||
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 } : {}),
|
||
submitted_at: Date.now(),
|
||
});
|
||
|
||
this.ctx.logger.info('[wave.fetch] 任务提交成功', {
|
||
taskId,
|
||
warehouseId: Number(warehouseId || 0),
|
||
structureCount: structures.length,
|
||
defaultQuantity,
|
||
fetchMode: normalizedFetchMode,
|
||
maxFetchQuantity: normalizedMaxFetchQuantity,
|
||
});
|
||
|
||
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,
|
||
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 } : {}),
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* 按策略与策略类型推导本次抓取的拣货模式。
|
||
*
|
||
* 优先使用显式入参 pick_mode/pickMode,其次回退到策略字段(strategy_type、batch_mode)。
|
||
*
|
||
* @param {Object} options 推导参数。
|
||
* @param {Object} [options.requestData={}] 请求参数。
|
||
* @param {Object} [options.strategyRow={}] 策略行数据。
|
||
* @return {number} 归一化后的拣货模式(1-5,异常时为 0)。
|
||
*/
|
||
resolveWaveStrategyFetchPickMode(options = {}) {
|
||
const requestData = this.isPlainObject(options && options.requestData)
|
||
? options.requestData
|
||
: {};
|
||
const strategyRow = this.isPlainObject(options && options.strategyRow)
|
||
? options.strategyRow
|
||
: {};
|
||
|
||
const explicitPickMode = Number(requestData.pick_mode ?? requestData.pickMode);
|
||
if (Number.isInteger(explicitPickMode) && explicitPickMode >= 1 && explicitPickMode <= 5) {
|
||
return explicitPickMode;
|
||
}
|
||
|
||
const strategyType = Number(strategyRow.strategy_type || 0);
|
||
const batchMode = Number(strategyRow.batch_mode || 0);
|
||
const groupBatchMaxOrders = Number(strategyRow.group_batch_max_orders || 0);
|
||
|
||
if (strategyType === 2) {
|
||
if (groupBatchMaxOrders > 1) {
|
||
return 1;
|
||
}
|
||
return 5;
|
||
}
|
||
|
||
if (batchMode === 1) {
|
||
return 2;
|
||
}
|
||
if (batchMode === 2) {
|
||
return 3;
|
||
}
|
||
if ([ 3, 4, 5, 6 ].includes(batchMode)) {
|
||
return 4;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 构建抓取策略的框分配规则(最小可执行结构)。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {number} options.pickMode 拣货模式。
|
||
* @param {Array<number>} [options.selectedWaveIds=[]] 预抓波次ID集合。
|
||
* @param {number} [options.boxLimit=0] 最大可用框数。
|
||
* @return {Array<Object>} 框分配规则列表。
|
||
*/
|
||
buildWaveStrategyFetchBoxAssignments(options = {}) {
|
||
const pickMode = Number(options && options.pickMode || 0);
|
||
const selectedWaveIds = Array.isArray(options && options.selectedWaveIds)
|
||
? options.selectedWaveIds
|
||
: [];
|
||
const boxLimit = Number(options && options.boxLimit || 0);
|
||
|
||
if (pickMode === 1) {
|
||
return selectedWaveIds.map((waveId, index) => ({
|
||
wave_id: waveId,
|
||
box_no: index + 1,
|
||
rule: 'one_wave_one_box',
|
||
}));
|
||
}
|
||
|
||
if (selectedWaveIds.length > 0) {
|
||
return [{
|
||
wave_id: selectedWaveIds[0],
|
||
box_no: 1,
|
||
rule: pickMode === 5 ? 'single_wave_dynamic_append' : 'single_wave_single_box',
|
||
}];
|
||
}
|
||
|
||
return [{
|
||
wave_id: 0,
|
||
box_no: 1,
|
||
rule: pickMode === 5 ? 'single_wave_dynamic_append' : 'single_wave_single_box',
|
||
box_limit: Number.isInteger(boxLimit) && boxLimit > 0 ? boxLimit : 1,
|
||
}];
|
||
}
|
||
|
||
/**
|
||
* 策略抓取前置预处理:统一输出标准化 plan。
|
||
*
|
||
* 仅做策略与参数预处理,不执行任务写库。
|
||
*
|
||
* @param {Object} params 预处理入参。
|
||
* @param {number|string} params.strategyId 策略ID。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Object} [params.operator={}] 操作人信息。
|
||
* @param {string} [params.source='unknown'] 来源标识(pda/admin)。
|
||
* @param {Object} [params.data={}] 原始请求参数。
|
||
* @return {Promise<Object>} 标准化抓取 plan。
|
||
*/
|
||
async prepareWaveStrategyFetchPlan(params = {}) {
|
||
const strategyId = this.normalizeRequiredPositiveInteger(params && params.strategyId, 'strategy_id');
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params && params.warehouseId, 'warehouse_id');
|
||
const source = String(params && params.source || 'unknown').trim() || 'unknown';
|
||
const operator = this.isPlainObject(params && params.operator) ? params.operator : {};
|
||
const requestData = this.isPlainObject(params && params.data) ? params.data : {};
|
||
const hasExplicitWaveSelectionInput = [
|
||
'selected_wave_ids',
|
||
'selectedWaveIds',
|
||
'wave_ids',
|
||
'waveIds',
|
||
'wave_id',
|
||
'waveId',
|
||
].some(fieldName => Object.prototype.hasOwnProperty.call(requestData, fieldName));
|
||
|
||
const plan = {
|
||
strategy_id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
source,
|
||
operator,
|
||
pick_mode: 0,
|
||
wave_limit: 0,
|
||
order_limit: 0,
|
||
sku_limit: 0,
|
||
box_limit: 0,
|
||
selected_wave_ids: [],
|
||
box_assignments: [],
|
||
dynamic_append: false,
|
||
validation_errors: [],
|
||
};
|
||
|
||
let strategyRows = [];
|
||
try {
|
||
strategyRows = await this.getWaveStrategyQuickScanStrategyRows(warehouseId);
|
||
} catch (error) {
|
||
strategyRows = [];
|
||
}
|
||
|
||
let strategyRow = (Array.isArray(strategyRows) ? strategyRows : []).find(item => {
|
||
const currentId = Number(item && (item.id ?? item.strategy_id ?? item.strategyId) || 0);
|
||
return Number.isInteger(currentId) && currentId === strategyId;
|
||
}) || null;
|
||
|
||
if (!strategyRow) {
|
||
const strategyModel = this.getWaveStrategyModel();
|
||
if (strategyModel && typeof strategyModel.findOne === 'function') {
|
||
const strategyEntity = await strategyModel.findOne({
|
||
where: {
|
||
id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
status: 1,
|
||
},
|
||
raw: true,
|
||
});
|
||
if (strategyEntity && typeof strategyEntity.get === 'function') {
|
||
strategyRow = strategyEntity.get({ plain: true });
|
||
} else {
|
||
strategyRow = strategyEntity || null;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!strategyRow) {
|
||
plan.validation_errors.push(`策略不存在或已停用: ${strategyId}`);
|
||
return plan;
|
||
}
|
||
|
||
plan.strategy_type = Number(strategyRow.strategy_type || 0);
|
||
plan.strategy_row = strategyRow;
|
||
|
||
const selectedWaveIds = this.normalizeIdsInput(
|
||
requestData.selected_wave_ids !== undefined
|
||
? requestData.selected_wave_ids
|
||
: requestData.selectedWaveIds !== undefined
|
||
? requestData.selectedWaveIds
|
||
: requestData.wave_ids !== undefined
|
||
? requestData.wave_ids
|
||
: requestData.waveIds !== undefined
|
||
? requestData.waveIds
|
||
: requestData.wave_id !== undefined
|
||
? requestData.wave_id
|
||
: requestData.waveId
|
||
);
|
||
plan.selected_wave_ids = selectedWaveIds;
|
||
|
||
const pickMode = this.resolveWaveStrategyFetchPickMode({
|
||
requestData,
|
||
strategyRow,
|
||
});
|
||
plan.pick_mode = pickMode;
|
||
|
||
if (![ 1, 2, 3, 4, 5 ].includes(pickMode)) {
|
||
plan.validation_errors.push('无法从策略推导有效 pick_mode,请显式传入 pick_mode(1-5)');
|
||
}
|
||
|
||
const rawBoxLimit = requestData.box_limit ?? requestData.boxLimit ?? strategyRow.group_batch_max_orders;
|
||
const normalizedBoxLimit = Number(rawBoxLimit);
|
||
plan.box_limit = Number.isInteger(normalizedBoxLimit) && normalizedBoxLimit > 0 ? normalizedBoxLimit : 1;
|
||
|
||
const rawOrderLimit = requestData.order_limit ?? requestData.orderLimit ?? strategyRow.batch_max_orders;
|
||
const normalizedOrderLimit = Number(rawOrderLimit);
|
||
plan.order_limit = Number.isInteger(normalizedOrderLimit) && normalizedOrderLimit > 0 ? normalizedOrderLimit : 0;
|
||
|
||
const rawSkuLimit = requestData.sku_limit ?? requestData.skuLimit ?? strategyRow.batch_max_skus;
|
||
const normalizedSkuLimit = Number(rawSkuLimit);
|
||
plan.sku_limit = Number.isInteger(normalizedSkuLimit) && normalizedSkuLimit > 0 ? normalizedSkuLimit : 0;
|
||
|
||
const rawWaveLimit = requestData.wave_limit ?? requestData.waveLimit;
|
||
const normalizedWaveLimit = Number(rawWaveLimit);
|
||
if (Number.isInteger(normalizedWaveLimit) && normalizedWaveLimit > 0) {
|
||
plan.wave_limit = normalizedWaveLimit;
|
||
} else {
|
||
plan.wave_limit = pickMode === 1 ? plan.box_limit : 1;
|
||
}
|
||
|
||
if (pickMode === 1) {
|
||
if (plan.box_limit <= 0) {
|
||
plan.validation_errors.push('小团购模式 box_limit 必须大于 0');
|
||
}
|
||
if (selectedWaveIds.length > plan.box_limit) {
|
||
plan.validation_errors.push(`小团购模式预抓波次数(${selectedWaveIds.length})超过 box_limit(${plan.box_limit})`);
|
||
}
|
||
}
|
||
|
||
if ([ 1, 5 ].includes(pickMode) && hasExplicitWaveSelectionInput && selectedWaveIds.length === 0) {
|
||
plan.validation_errors.push('当前模式依赖波次,selected_wave_ids 不能为空');
|
||
}
|
||
|
||
if ([ 2, 3, 4 ].includes(pickMode) && selectedWaveIds.length > 1) {
|
||
plan.validation_errors.push('单品单件/先拣后分/边拣边分模式一次仅支持一个波次');
|
||
}
|
||
|
||
if (pickMode === 2 && plan.order_limit <= 0) {
|
||
plan.validation_errors.push('单品单件模式 order_limit 必须大于 0');
|
||
}
|
||
|
||
if (pickMode === 3 && plan.sku_limit <= 0) {
|
||
plan.validation_errors.push('先拣后分模式 sku_limit 必须大于 0');
|
||
}
|
||
|
||
if (pickMode === 5) {
|
||
plan.dynamic_append = true;
|
||
if (selectedWaveIds.length > 1) {
|
||
plan.validation_errors.push('大团购模式一次仅支持一个波次(后续追加采用动态扫描)');
|
||
}
|
||
}
|
||
|
||
plan.box_assignments = this.buildWaveStrategyFetchBoxAssignments({
|
||
pickMode,
|
||
selectedWaveIds,
|
||
boxLimit: plan.box_limit,
|
||
});
|
||
|
||
return plan;
|
||
}
|
||
|
||
/**
|
||
* 校验当前操作用户是否存在未完成任务。
|
||
*
|
||
* 活跃状态定义:status in (0,1),不包含已完成(status=2)的任务。
|
||
*
|
||
* @param {Object} params 校验参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {number|string} params.operatorId 操作用户ID。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async ensureNoActiveWavePickTaskForOperator(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const operatorId = Number(params.operatorId || 0);
|
||
const transaction = params.transaction;
|
||
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return;
|
||
}
|
||
|
||
const rows = await this.ctx.model.query(`
|
||
SELECT id, task_no
|
||
FROM wms_wave_pick_task
|
||
WHERE warehouse_id = :warehouseId
|
||
AND pick_user_id = :operatorId
|
||
AND status IN (0, 1)
|
||
ORDER BY id DESC
|
||
LIMIT 1
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
warehouseId,
|
||
operatorId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const activeTask = Array.isArray(rows) ? rows[0] : null;
|
||
if (activeTask) {
|
||
const taskNo = String(activeTask.task_no || '').trim();
|
||
const taskId = Number(activeTask.id || 0);
|
||
throw new Error(`当前用户存在未完成任务,请先完成后再创建(task_id=${taskId}${taskNo ? `,task_no=${taskNo}` : ''})`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询策略自动分流候选订单(命中策略且未分配波次)。
|
||
*
|
||
* 过滤口径:step != 0、wave_id = 0、status != cancel、outbound_status != padding,
|
||
* 并按同结构数量命中 min_same_structure/max_same_structure。
|
||
*
|
||
* @param {Object} params 查询参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {number|string} params.strategyId 策略ID。
|
||
* @param {number|string|null} [params.minSameStructure=0] 最小同结构数量。
|
||
* @param {number|string|null} [params.maxSameStructure=null] 最大同结构数量。
|
||
* @return {Promise<Array<Object>>} 候选订单数组(按 order_id 升序)。
|
||
*/
|
||
async getWaveStrategyFetchCandidateOrders(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const strategyId = this.normalizeRequiredPositiveInteger(params.strategyId, 'strategy_id');
|
||
const minSameStructureRaw = Number(params.minSameStructure ?? 0);
|
||
const maxSameStructureRaw = Number(params.maxSameStructure);
|
||
const minSameStructure = Number.isFinite(minSameStructureRaw) && minSameStructureRaw > 0
|
||
? Math.floor(minSameStructureRaw)
|
||
: 0;
|
||
const maxSameStructure = Number.isFinite(maxSameStructureRaw) && maxSameStructureRaw > 0
|
||
? Math.floor(maxSameStructureRaw)
|
||
: null;
|
||
const requireSameExpress = Number(params.requireSameExpress ?? 0) === 1;
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const orderTableName = this.getModelTableSqlName(orderModel);
|
||
const structureExpr = alias => `${alias}.items_hash`;
|
||
const expressExpr = alias => `COALESCE(NULLIF(TRIM(COALESCE(${alias}.sys_logistics_code, '')), ''), NULLIF(TRIM(COALESCE(${alias}.logistics_code, '')), ''), TRIM(COALESCE(${alias}.logistics_name, '')))`;
|
||
const groupKeyExtra = requireSameExpress ? `, ${expressExpr('src')}` : '';
|
||
const joinKeyExtra = requireSameExpress ? ` AND same_structure.express_key = ${expressExpr('o')}` : '';
|
||
const rows = await this.ctx.model.query(`
|
||
SELECT
|
||
o.id,
|
||
o.items_hash,
|
||
o.items,
|
||
o.logistics_name,
|
||
o.sys_logistics_code,
|
||
o.logistics_code,
|
||
o.items_count,
|
||
o.items_total
|
||
FROM wms_order_wave_strategy_match m
|
||
INNER JOIN ${orderTableName} o
|
||
ON o.id = m.order_id
|
||
AND o.warehouse_id = :warehouseId
|
||
AND o.wave_id = 0
|
||
AND o.step != 0
|
||
AND o.post_status = 'fin'
|
||
AND o.storage_status = 'fin'
|
||
AND o.print_status != 'fin'
|
||
AND o.status != 'cancel'
|
||
AND o.outbound_status != 'padding'
|
||
AND o.intercept_status = 'none'
|
||
AND o.lock_status = 'none'
|
||
INNER JOIN (
|
||
SELECT
|
||
${structureExpr('src')} AS structure_key${requireSameExpress ? `, ${expressExpr('src')} AS express_key` : ''},
|
||
COUNT(1) AS same_structure_count
|
||
FROM ${orderTableName} src
|
||
WHERE src.warehouse_id = :warehouseId
|
||
AND src.wave_id = 0
|
||
AND src.step != 0
|
||
AND src.post_status = 'fin'
|
||
AND src.storage_status = 'fin'
|
||
AND src.print_status != 'fin'
|
||
AND src.status != 'cancel'
|
||
AND src.outbound_status != 'padding'
|
||
AND src.intercept_status = 'none'
|
||
AND src.lock_status = 'none'
|
||
GROUP BY ${structureExpr('src')}${groupKeyExtra}
|
||
) same_structure
|
||
ON same_structure.structure_key = ${structureExpr('o')}${joinKeyExtra}
|
||
WHERE m.warehouse_id = :warehouseId
|
||
AND m.strategy_id = :strategyId
|
||
AND same_structure.same_structure_count >= :minSameStructure
|
||
AND (:maxSameStructure IS NULL OR same_structure.same_structure_count <= :maxSameStructure)
|
||
ORDER BY o.id ASC
|
||
`, {
|
||
replacements: {
|
||
warehouseId,
|
||
strategyId,
|
||
minSameStructure,
|
||
maxSameStructure,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
return (Array.isArray(rows) ? rows : [])
|
||
.map(row => ({
|
||
id: Number(row && row.id || 0),
|
||
items_hash: String(row && row.items_hash || '').trim(),
|
||
items: String(row && row.items || '').trim(),
|
||
logistics_name: String(row && row.logistics_name || '').trim(),
|
||
sys_logistics_code: String(row && row.sys_logistics_code || '').trim(),
|
||
logistics_code: String(row && row.logistics_code || '').trim(),
|
||
items_count: Number(row && row.items_count || 0),
|
||
items_total: Number(row && row.items_total || 0),
|
||
}))
|
||
.filter(row => Number.isInteger(row.id) && row.id > 0)
|
||
.sort((a, b) => a.id - b.id);
|
||
}
|
||
|
||
/**
|
||
* 按订单结构对候选订单分组。
|
||
*
|
||
* @param {Array<Object>} candidateRows 候选订单数组。
|
||
* @return {Array<Object>} 分组结果(含 group_min_order_id)。
|
||
*/
|
||
groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows = []) {
|
||
const groupedMap = new Map();
|
||
const rows = Array.isArray(candidateRows) ? candidateRows : [];
|
||
|
||
for (const row of rows) {
|
||
const structureKey = this.getWaveStrategyQuickScanStructureKey(row);
|
||
if (!structureKey) {
|
||
continue;
|
||
}
|
||
|
||
if (!groupedMap.has(structureKey)) {
|
||
groupedMap.set(structureKey, []);
|
||
}
|
||
groupedMap.get(structureKey).push(row);
|
||
}
|
||
|
||
return Array.from(groupedMap.entries())
|
||
.map(([ structureKey, orders ]) => {
|
||
const sortedOrders = orders
|
||
.map(item => ({ ...item }))
|
||
.sort((a, b) => Number(a.id || 0) - Number(b.id || 0));
|
||
const minOrderId = sortedOrders.length > 0 ? Number(sortedOrders[0].id || 0) : 0;
|
||
return {
|
||
structure_key: structureKey,
|
||
group_min_order_id: minOrderId,
|
||
orders: sortedOrders,
|
||
order_ids: sortedOrders.map(item => Number(item.id || 0)).filter(id => Number.isInteger(id) && id > 0),
|
||
};
|
||
})
|
||
.filter(group => group.order_ids.length > 0)
|
||
.sort((a, b) => a.group_min_order_id - b.group_min_order_id);
|
||
}
|
||
|
||
/**
|
||
* 读取订单商品明细并构建每单 SKU 集合。
|
||
*
|
||
* @param {Object} params 构建参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Array<number>} params.orderIds 订单ID数组。
|
||
* @return {Promise<Map<number, Set<string>>>} order_id 到 SKU 集合映射。
|
||
*/
|
||
async buildWaveStrategyFetchOrderSkuMap(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const orderIds = this.normalizeIdsInput(params.orderIds || []);
|
||
if (orderIds.length === 0) {
|
||
return new Map();
|
||
}
|
||
|
||
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
|
||
if (!orderItemsModel || typeof orderItemsModel.findAll !== 'function') {
|
||
throw new Error('订单明细模型不可用');
|
||
}
|
||
|
||
const itemRows = 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 rowMap = new Map();
|
||
for (const row of (Array.isArray(itemRows) ? itemRows : [])) {
|
||
const orderId = Number(row && row.order_id || 0);
|
||
if (!Number.isInteger(orderId) || orderId <= 0) {
|
||
continue;
|
||
}
|
||
|
||
if (!rowMap.has(orderId)) {
|
||
rowMap.set(orderId, []);
|
||
}
|
||
rowMap.get(orderId).push(row);
|
||
}
|
||
|
||
const skuMap = new Map();
|
||
for (const orderId of orderIds) {
|
||
const detailRows = rowMap.get(orderId) || [];
|
||
const detailList = this.mergeOrderItemDetails(detailRows);
|
||
const skuSet = new Set();
|
||
|
||
detailList.forEach(item => {
|
||
const itemCode = String(item && item.item_code || '').trim();
|
||
const stockId = Number(item && item.stock_id || 0);
|
||
if (itemCode) {
|
||
skuSet.add(itemCode);
|
||
return;
|
||
}
|
||
if (Number.isInteger(stockId) && stockId > 0) {
|
||
skuSet.add(`stock_${stockId}`);
|
||
}
|
||
});
|
||
|
||
skuMap.set(orderId, skuSet);
|
||
}
|
||
|
||
return skuMap;
|
||
}
|
||
|
||
/**
|
||
* 先拣后分模式按 SKU 上限筛选订单。
|
||
*
|
||
* 当 SKU 种类超限时,循环剔除“出现频率最低”的 SKU,
|
||
* 每次剔除该 SKU 对应的全部订单,直到 SKU 种类满足上限。
|
||
*
|
||
* @param {Object} params 筛选参数。
|
||
* @param {Array<number>} params.orderIds 候选订单ID(升序)。
|
||
* @param {Map<number, Set<string>>} params.orderSkuMap 订单 SKU 映射。
|
||
* @param {number|string} params.skuLimit SKU 上限。
|
||
* @return {{ selectedOrderIds: Array<number>, removedOrderIds: Array<number> }} 筛选结果。
|
||
*/
|
||
selectWaveStrategyFetchOrdersBySkuLimit(params = {}) {
|
||
const orderIds = this.normalizeIdsInput(params.orderIds || []);
|
||
const orderSkuMap = params.orderSkuMap instanceof Map ? params.orderSkuMap : new Map();
|
||
const skuLimitRaw = Number(params.skuLimit || 0);
|
||
const skuLimit = Number.isInteger(skuLimitRaw) && skuLimitRaw > 0 ? skuLimitRaw : 0;
|
||
|
||
if (orderIds.length === 0) {
|
||
return {
|
||
selectedOrderIds: [],
|
||
removedOrderIds: [],
|
||
};
|
||
}
|
||
|
||
if (skuLimit <= 0) {
|
||
return {
|
||
selectedOrderIds: [],
|
||
removedOrderIds: [ ...orderIds ],
|
||
};
|
||
}
|
||
|
||
const activeOrderSet = new Set(orderIds);
|
||
const removedOrderSet = new Set();
|
||
|
||
const buildSkuOrderMap = () => {
|
||
const skuOrderMap = new Map();
|
||
for (const orderId of activeOrderSet) {
|
||
const skuSet = orderSkuMap.get(orderId) instanceof Set ? orderSkuMap.get(orderId) : new Set();
|
||
for (const sku of skuSet) {
|
||
const skuKey = String(sku || '').trim();
|
||
if (!skuKey) {
|
||
continue;
|
||
}
|
||
if (!skuOrderMap.has(skuKey)) {
|
||
skuOrderMap.set(skuKey, new Set());
|
||
}
|
||
skuOrderMap.get(skuKey).add(orderId);
|
||
}
|
||
}
|
||
return skuOrderMap;
|
||
};
|
||
|
||
for (;;) {
|
||
const skuOrderMap = buildSkuOrderMap();
|
||
if (skuOrderMap.size <= skuLimit) {
|
||
break;
|
||
}
|
||
|
||
let targetSku = '';
|
||
let minFrequency = Number.MAX_SAFE_INTEGER;
|
||
for (const [ sku, orderSet ] of skuOrderMap.entries()) {
|
||
const frequency = orderSet.size;
|
||
if (frequency < minFrequency) {
|
||
minFrequency = frequency;
|
||
targetSku = sku;
|
||
continue;
|
||
}
|
||
if (frequency === minFrequency && targetSku && String(sku).localeCompare(String(targetSku)) < 0) {
|
||
targetSku = sku;
|
||
}
|
||
}
|
||
|
||
if (!targetSku) {
|
||
break;
|
||
}
|
||
|
||
const targetOrderSet = skuOrderMap.get(targetSku) || new Set();
|
||
for (const orderId of targetOrderSet) {
|
||
if (activeOrderSet.has(orderId)) {
|
||
activeOrderSet.delete(orderId);
|
||
removedOrderSet.add(orderId);
|
||
}
|
||
}
|
||
|
||
if (activeOrderSet.size === 0) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return {
|
||
selectedOrderIds: [ ...activeOrderSet ].sort((a, b) => a - b),
|
||
removedOrderIds: [ ...removedOrderSet ].sort((a, b) => a - b),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 在事务内按指定订单创建波次并更新订单波次字段。
|
||
*
|
||
* @param {Object} params 创建参数。
|
||
* @param {number|string} params.warehouseId 仓库ID。
|
||
* @param {Array<number|string>} params.orderIds 订单ID数组。
|
||
* @param {number|string} params.waveType 波次类型(1-团购,2-散单)。
|
||
* @param {string} params.wavePrefix 波次前缀。
|
||
* @param {number|string} [params.source=0] 波次来源。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<{ waveId: number, waveNo: string, selectedOrderIds: Array<number> }>} 创建结果。
|
||
*/
|
||
async createWaveBatchByOrderIdsInTransaction(params = {}) {
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const waveType = Number(params.waveType || 0) === 2 ? 2 : 1;
|
||
const wavePrefix = String(params.wavePrefix || '').trim() || (waveType === 2 ? 'A' : 'B');
|
||
const sourceInput = Number(params.source);
|
||
const source = [ 0, 1, 2 ].includes(sourceInput) ? sourceInput : 0;
|
||
const transaction = params.transaction;
|
||
const orderIds = this.normalizeIdsInput(params.orderIds || []);
|
||
if (orderIds.length === 0) {
|
||
throw new Error('创建波次失败:订单集合不能为空');
|
||
}
|
||
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const lockRows = await orderModel.findAll({
|
||
attributes: [ 'id', 'wave_id', 'items_hash', 'items' ],
|
||
where: {
|
||
id: { [Op.in]: orderIds },
|
||
warehouse_id: warehouseId,
|
||
wave_id: 0,
|
||
step: { [Op.ne]: 0 },
|
||
status: { [Op.ne]: 'cancel' },
|
||
outbound_status: { [Op.ne]: 'padding' },
|
||
},
|
||
raw: true,
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
});
|
||
|
||
const fetchableOrderIds = [ ...new Set((Array.isArray(lockRows) ? lockRows : [])
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ].sort((a, b) => a - b);
|
||
|
||
if (fetchableOrderIds.length === 0) {
|
||
throw new Error('创建波次失败:候选订单已被占用或状态变化');
|
||
}
|
||
|
||
const firstRow = Array.isArray(lockRows) ? lockRows[0] : null;
|
||
const itemPart = this.getOrderItemPart(firstRow || {});
|
||
const itemSnapshotKey = `${itemPart.item_part_type}:${itemPart.item_part}`;
|
||
const itemDetailMachine = this.buildMachineStructureToken({
|
||
item_part_type: itemPart.item_part_type,
|
||
item_part: itemPart.item_part,
|
||
distinguish_express: false,
|
||
logistics_name: '',
|
||
item_snapshot_key: itemSnapshotKey,
|
||
});
|
||
|
||
const { waveId, waveNo } = await this.createWaveBatchReady({
|
||
warehouseId,
|
||
totalOrders: fetchableOrderIds.length,
|
||
itemDetailMachine,
|
||
itemPartType: itemPart.item_part_type,
|
||
itemPart: itemPart.item_part,
|
||
distinguishExpress: false,
|
||
logisticsName: '',
|
||
itemSnapshotKey,
|
||
wavePrefix,
|
||
waveType,
|
||
source,
|
||
transaction,
|
||
});
|
||
|
||
await orderModel.update({
|
||
wave_id: waveId,
|
||
wave_no: waveNo,
|
||
}, {
|
||
where: {
|
||
id: { [Op.in]: fetchableOrderIds },
|
||
warehouse_id: warehouseId,
|
||
wave_id: 0,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const grabbedRows = await orderModel.findAll({
|
||
where: {
|
||
id: { [Op.in]: fetchableOrderIds },
|
||
warehouse_id: warehouseId,
|
||
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,
|
||
});
|
||
throw new Error('创建波次失败:未抓取到有效订单');
|
||
}
|
||
|
||
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,
|
||
});
|
||
|
||
return {
|
||
waveId,
|
||
waveNo,
|
||
selectedOrderIds: grabbedOrderIds,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 自动补齐按策略抓取的 selected_wave_ids / selected_order_ids。
|
||
*
|
||
* 仅用于 PDA 按策略抓取场景,内部按 strategy_type + pick_mode 执行分流。
|
||
*
|
||
* @param {Object} params 自动分流参数。
|
||
* @param {Object} params.plan 抓取计划。
|
||
* @param {Object} params.strategyRow 策略行。
|
||
* @param {number|string} [params.waveBatchSource=0] 波次来源。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<Object>} 自动补齐结果。
|
||
*/
|
||
async autoPopulateWaveStrategyFetchSelections(params = {}) {
|
||
const plan = this.isPlainObject(params.plan) ? params.plan : {};
|
||
const strategyRow = this.isPlainObject(params.strategyRow) ? params.strategyRow : {};
|
||
const transaction = params.transaction;
|
||
const waveBatchSourceInput = Number(params.waveBatchSource);
|
||
const waveBatchSource = [ 0, 1, 2 ].includes(waveBatchSourceInput) ? waveBatchSourceInput : 0;
|
||
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const strategyId = this.normalizeRequiredPositiveInteger(plan.strategy_id, 'strategy_id');
|
||
const pickMode = this.normalizeRequiredPositiveInteger(plan.pick_mode, 'pick_mode');
|
||
const strategyType = Number(strategyRow.strategy_type || plan.strategy_type || 0);
|
||
const operatorInfo = this.isPlainObject(plan.operator) ? plan.operator : {};
|
||
const operatorId = Number((operatorInfo.operator_id ?? operatorInfo.id) || 0);
|
||
|
||
await this.ensureNoActiveWavePickTaskForOperator({
|
||
warehouseId,
|
||
operatorId,
|
||
transaction,
|
||
});
|
||
|
||
const candidateRows = await this.getWaveStrategyFetchCandidateOrders({
|
||
warehouseId,
|
||
strategyId,
|
||
minSameStructure: strategyRow.min_same_structure,
|
||
maxSameStructure: strategyRow.max_same_structure,
|
||
requireSameExpress: Number(strategyRow.require_same_express || 0),
|
||
});
|
||
const candidateCount = candidateRows.length;
|
||
if (candidateCount <= 0) {
|
||
throw new Error('未找到符合策略且未分配波次的候选订单');
|
||
}
|
||
|
||
const groupedRows = this.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows);
|
||
if (groupedRows.length <= 0) {
|
||
throw new Error('候选订单缺少有效商品结构,无法创建波次');
|
||
}
|
||
|
||
const result = {
|
||
selected_wave_ids: [],
|
||
selected_order_ids: [],
|
||
removed_order_ids: [],
|
||
candidate_count: candidateCount,
|
||
grouped_count: groupedRows.length,
|
||
wave_prefix: '',
|
||
wave_prefix_source: '',
|
||
};
|
||
|
||
const wavePrefixResolution = await this.resolveWaveStrategyFetchWavePrefix({
|
||
warehouseId,
|
||
strategyType,
|
||
strategyRow,
|
||
});
|
||
result.wave_prefix = wavePrefixResolution.wavePrefix;
|
||
result.wave_prefix_source = wavePrefixResolution.source;
|
||
|
||
if (strategyType === 2) {
|
||
const effectiveGroupedRows = Number(strategyRow.require_same_express || 0) === 1
|
||
? this.groupWaveStrategyFetchCandidateOrdersByStructure(
|
||
this.filterCandidateOrdersByRequireSameExpress(candidateRows)
|
||
)
|
||
: groupedRows;
|
||
const groupLimitRaw = Number(strategyRow.group_batch_max_orders || plan.box_limit || 0);
|
||
const groupLimit = Number.isInteger(groupLimitRaw) && groupLimitRaw > 0 ? groupLimitRaw : 1;
|
||
const selectedGroups = effectiveGroupedRows
|
||
.slice(0, groupLimit);
|
||
if (selectedGroups.length === 0) {
|
||
throw new Error('团购策略未找到可创建波次的同结构分组');
|
||
}
|
||
|
||
for (const group of selectedGroups) {
|
||
const created = await this.createWaveBatchByOrderIdsInTransaction({
|
||
warehouseId,
|
||
orderIds: group.order_ids,
|
||
waveType: 1,
|
||
wavePrefix: wavePrefixResolution.wavePrefix,
|
||
source: waveBatchSource,
|
||
transaction,
|
||
});
|
||
result.selected_wave_ids.push(created.waveId);
|
||
result.selected_order_ids.push(...created.selectedOrderIds);
|
||
}
|
||
|
||
if (result.selected_wave_ids.length <= 0) {
|
||
throw new Error('团购策略创建波次失败:无有效波次生成');
|
||
}
|
||
} else if (strategyType === 1) {
|
||
const effectiveCandidateRows = Number(strategyRow.require_same_express || 0) === 1
|
||
? this.filterCandidateOrdersByRequireSameExpress(candidateRows)
|
||
: candidateRows;
|
||
const effectiveGroupedRows = effectiveCandidateRows === candidateRows
|
||
? groupedRows
|
||
: this.groupWaveStrategyFetchCandidateOrdersByStructure(effectiveCandidateRows);
|
||
|
||
const mergedOrderIds = [ ...new Set(effectiveGroupedRows
|
||
.flatMap(group => group.order_ids)
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
if (mergedOrderIds.length === 0) {
|
||
throw new Error('散单策略无可用候选订单');
|
||
}
|
||
|
||
const orderLimitRaw = Number(plan.order_limit || strategyRow.batch_max_orders || 0);
|
||
const orderLimit = Number.isInteger(orderLimitRaw) && orderLimitRaw > 0 ? orderLimitRaw : 0;
|
||
let selectedOrderIds = [];
|
||
|
||
if (pickMode === 3) {
|
||
const skuMap = await this.buildWaveStrategyFetchOrderSkuMap({
|
||
warehouseId,
|
||
orderIds: mergedOrderIds,
|
||
});
|
||
const skuLimitRaw = Number(plan.sku_limit || strategyRow.batch_max_skus || 0);
|
||
const skuLimit = Number.isInteger(skuLimitRaw) && skuLimitRaw > 0 ? skuLimitRaw : 0;
|
||
const skuResult = this.selectWaveStrategyFetchOrdersBySkuLimit({
|
||
orderIds: mergedOrderIds,
|
||
orderSkuMap: skuMap,
|
||
skuLimit,
|
||
});
|
||
result.removed_order_ids = skuResult.removedOrderIds;
|
||
selectedOrderIds = skuResult.selectedOrderIds;
|
||
} else if (pickMode === 4 || pickMode === 2) {
|
||
selectedOrderIds = mergedOrderIds;
|
||
} else {
|
||
throw new Error(`散单策略不支持的 pick_mode: ${pickMode}`);
|
||
}
|
||
|
||
if (selectedOrderIds.length <= 0) {
|
||
throw new Error('散单策略筛选后无可用订单(候选可能已被剔除)');
|
||
}
|
||
|
||
const limitedOrderIds = orderLimit > 0
|
||
? selectedOrderIds.slice(0, orderLimit)
|
||
: selectedOrderIds;
|
||
if (limitedOrderIds.length <= 0) {
|
||
throw new Error('散单策略筛选后无可用订单(batch_max_orders 限制导致为空)');
|
||
}
|
||
|
||
const createdWave = await this.createWaveBatchByOrderIdsInTransaction({
|
||
warehouseId,
|
||
orderIds: limitedOrderIds,
|
||
waveType: 2,
|
||
wavePrefix: wavePrefixResolution.wavePrefix,
|
||
source: waveBatchSource,
|
||
transaction,
|
||
});
|
||
|
||
result.selected_wave_ids.push(createdWave.waveId);
|
||
result.selected_order_ids.push(...createdWave.selectedOrderIds);
|
||
if (result.selected_wave_ids.length <= 0) {
|
||
throw new Error('散单策略创建波次失败:无有效波次生成');
|
||
}
|
||
} else {
|
||
throw new Error(`不支持的策略类型: ${strategyType}`);
|
||
}
|
||
|
||
result.selected_wave_ids = [ ...new Set(result.selected_wave_ids) ].sort((a, b) => a - b);
|
||
result.selected_order_ids = [ ...new Set(result.selected_order_ids) ].sort((a, b) => a - b);
|
||
|
||
this.ctx.logger.info('[wave.autoPopulateWaveStrategyFetchSelections] 自动分流完成', {
|
||
strategy_id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
pick_mode: pickMode,
|
||
strategy_type: strategyType,
|
||
wave_prefix: result.wave_prefix,
|
||
wave_prefix_source: result.wave_prefix_source,
|
||
candidate_count: result.candidate_count,
|
||
removed_count: result.removed_order_ids.length,
|
||
selected_count: result.selected_order_ids.length,
|
||
selected_wave_count: result.selected_wave_ids.length,
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 按策略直接抓取候选订单并创建波次(不创建拣货任务)。
|
||
*
|
||
* 在一个事务内完成候选查询、分组与建波:
|
||
* - 团购策略(strategy_type=2):每个结构分组创建一个波次;
|
||
* - 散单策略(strategy_type=1):合并全部候选订单后创建一个散单波次。
|
||
*
|
||
* @param {Object} params 执行参数。
|
||
* @param {Object} params.plan 预处理计划。
|
||
* @param {Object} [params.strategyRow={}] 策略行(可选,默认取 plan.strategy_row)。
|
||
* @param {number|string} [params.waveBatchSource=0] 波次来源:0-普通波次 1-管理后台策略抓取 2-PDA策略抓取。
|
||
* @return {Promise<Object>} 建波结果汇总。
|
||
*/
|
||
async executeWaveStrategyDirectFetch(params = {}) {
|
||
const plan = this.isPlainObject(params && params.plan) ? params.plan : {};
|
||
const strategyRow = this.isPlainObject(params && params.strategyRow)
|
||
? params.strategyRow
|
||
: (this.isPlainObject(plan.strategy_row) ? plan.strategy_row : {});
|
||
const waveBatchSourceInput = Number(params && params.waveBatchSource);
|
||
const waveBatchSource = [ 0, 1, 2 ].includes(waveBatchSourceInput) ? waveBatchSourceInput : 0;
|
||
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const strategyId = this.normalizeRequiredPositiveInteger(plan.strategy_id, 'strategy_id');
|
||
const strategyType = Number(strategyRow.strategy_type || plan.strategy_type || 0);
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
const candidateRows = await this.getWaveStrategyFetchCandidateOrders({
|
||
warehouseId,
|
||
strategyId,
|
||
minSameStructure: strategyRow.min_same_structure,
|
||
maxSameStructure: strategyRow.max_same_structure,
|
||
requireSameExpress: Number(strategyRow.require_same_express || 0),
|
||
});
|
||
const candidateCount = candidateRows.length;
|
||
if (candidateCount <= 0) {
|
||
throw new Error('未找到符合策略且未分配波次的候选订单');
|
||
}
|
||
|
||
const groupedRows = this.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows);
|
||
if (groupedRows.length <= 0) {
|
||
throw new Error('候选订单缺少有效商品结构,无法创建波次');
|
||
}
|
||
|
||
const wavePrefixResolution = await this.resolveWaveStrategyFetchWavePrefix({
|
||
warehouseId,
|
||
strategyType,
|
||
strategyRow,
|
||
});
|
||
|
||
const createdWaveIds = [];
|
||
const createdWaveNos = [];
|
||
const createdOrderIds = [];
|
||
|
||
if (strategyType === 2) {
|
||
const effectiveGroupedRows = Number(strategyRow.require_same_express || 0) === 1
|
||
? this.groupWaveStrategyFetchCandidateOrdersByStructure(
|
||
this.filterCandidateOrdersByRequireSameExpress(candidateRows)
|
||
)
|
||
: groupedRows;
|
||
for (const group of effectiveGroupedRows) {
|
||
const created = await this.createWaveBatchByOrderIdsInTransaction({
|
||
warehouseId,
|
||
orderIds: group.order_ids,
|
||
waveType: 1,
|
||
wavePrefix: wavePrefixResolution.wavePrefix,
|
||
source: waveBatchSource,
|
||
transaction,
|
||
});
|
||
createdWaveIds.push(created.waveId);
|
||
createdWaveNos.push(created.waveNo);
|
||
createdOrderIds.push(...created.selectedOrderIds);
|
||
}
|
||
} else if (strategyType === 1) {
|
||
const effectiveCandidateRows = Number(strategyRow.require_same_express || 0) === 1
|
||
? this.filterCandidateOrdersByRequireSameExpress(candidateRows)
|
||
: candidateRows;
|
||
const effectiveGroupedRows = effectiveCandidateRows === candidateRows
|
||
? groupedRows
|
||
: this.groupWaveStrategyFetchCandidateOrdersByStructure(effectiveCandidateRows);
|
||
|
||
const mergedOrderIds = [ ...new Set(effectiveGroupedRows
|
||
.flatMap(group => group.order_ids)
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ]
|
||
.sort((a, b) => a - b);
|
||
if (mergedOrderIds.length <= 0) {
|
||
throw new Error('散单策略无可用候选订单');
|
||
}
|
||
|
||
const createdWave = await this.createWaveBatchByOrderIdsInTransaction({
|
||
warehouseId,
|
||
orderIds: mergedOrderIds,
|
||
waveType: 2,
|
||
wavePrefix: wavePrefixResolution.wavePrefix,
|
||
source: waveBatchSource,
|
||
transaction,
|
||
});
|
||
createdWaveIds.push(createdWave.waveId);
|
||
createdWaveNos.push(createdWave.waveNo);
|
||
createdOrderIds.push(...createdWave.selectedOrderIds);
|
||
} else {
|
||
throw new Error(`不支持的策略类型: ${strategyType}`);
|
||
}
|
||
|
||
const normalizedWaveIds = [ ...new Set(createdWaveIds) ].sort((a, b) => a - b);
|
||
const normalizedWaveNos = [ ...new Set(createdWaveNos.map(item => String(item || '').trim()).filter(Boolean)) ];
|
||
const normalizedOrderIds = [ ...new Set(createdOrderIds) ].sort((a, b) => a - b);
|
||
|
||
if (normalizedWaveIds.length <= 0 || normalizedOrderIds.length <= 0) {
|
||
throw new Error('按策略抓取建波失败:未生成有效波次或订单结果');
|
||
}
|
||
|
||
const result = {
|
||
wave_ids: normalizedWaveIds,
|
||
wave_nos: normalizedWaveNos,
|
||
order_ids: normalizedOrderIds,
|
||
created_wave_count: normalizedWaveIds.length,
|
||
created_order_count: normalizedOrderIds.length,
|
||
wave_prefix: wavePrefixResolution.wavePrefix,
|
||
wave_prefix_source: wavePrefixResolution.source,
|
||
candidate_count: candidateCount,
|
||
grouped_count: groupedRows.length,
|
||
strategy_type: strategyType,
|
||
};
|
||
|
||
await transaction.commit();
|
||
|
||
// 写入订单操作日志:策略抓取分配到波次
|
||
const strategyLogItems = normalizedOrderIds.map(orderId => ({
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_STRATEGY_FETCH',
|
||
message: `策略(${strategyId})抓取分配到波次 ${normalizedWaveNos.join(',')}`,
|
||
}));
|
||
await this.batchCreateOrderOperationLogs(strategyLogItems, {
|
||
warehouseId,
|
||
scene: 'executeWaveStrategyDirectFetch',
|
||
});
|
||
|
||
this.ctx.logger.info('[wave.executeWaveStrategyDirectFetch] 按策略直接建波完成', {
|
||
strategy_id: strategyId,
|
||
warehouse_id: warehouseId,
|
||
strategy_type: strategyType,
|
||
wave_prefix: result.wave_prefix,
|
||
wave_prefix_source: result.wave_prefix_source,
|
||
candidate_count: result.candidate_count,
|
||
grouped_count: result.grouped_count,
|
||
created_wave_count: result.created_wave_count,
|
||
created_order_count: result.created_order_count,
|
||
});
|
||
|
||
return result;
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行按策略抓取任务创建主流程。
|
||
*
|
||
* 该方法在一个事务内完成任务主表、明细表、断点与日志的初始化写入。
|
||
*
|
||
* @param {Object} params 创建参数。
|
||
* @param {Object} params.plan 预处理后的抓取计划。
|
||
* @param {Object} [params.data={}] 原始请求数据。
|
||
* @param {number|string} [params.waveBatchSource=0] 波次来源:0-普通波次 1-管理后台策略任务 2-PDA策略任务。
|
||
* @return {Promise<Object>} 创建结果。
|
||
*/
|
||
async createWavePickTaskFromPlan(params = {}) {
|
||
const plan = this.isPlainObject(params && params.plan) ? params.plan : {};
|
||
const requestData = this.isPlainObject(params && params.data) ? params.data : {};
|
||
const autoPopulateSelections = Boolean(params && params.autoPopulateSelections);
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const pickMode = this.normalizeRequiredPositiveInteger(plan.pick_mode, 'pick_mode');
|
||
const waveBatchSourceInput = Number(
|
||
params && params.waveBatchSource !== undefined ? params.waveBatchSource : plan.wave_batch_source
|
||
);
|
||
const waveBatchSource = [ 0, 1, 2 ].includes(waveBatchSourceInput) ? waveBatchSourceInput : 0;
|
||
let effectivePlan = {
|
||
...plan,
|
||
};
|
||
let effectiveRequestData = {
|
||
...requestData,
|
||
};
|
||
const hasExplicitWaveSelectionInput = [
|
||
'selected_wave_ids',
|
||
'selectedWaveIds',
|
||
'wave_ids',
|
||
'waveIds',
|
||
'wave_id',
|
||
'waveId',
|
||
].some(fieldName => Object.prototype.hasOwnProperty.call(requestData, fieldName));
|
||
const hasExplicitOrderSelectionInput = [
|
||
'selected_order_ids',
|
||
'selectedOrderIds',
|
||
'order_ids',
|
||
'orderIds',
|
||
].some(fieldName => Object.prototype.hasOwnProperty.call(requestData, fieldName));
|
||
const hasManualSelectionInput = this.normalizeIdsInput(plan.selected_wave_ids || []).length > 0
|
||
|| hasExplicitWaveSelectionInput
|
||
|| hasExplicitOrderSelectionInput;
|
||
|
||
const normalizedCartId = this.normalizePositiveInteger(
|
||
effectiveRequestData.cart_id ?? effectiveRequestData.cartId,
|
||
'cart_id',
|
||
0
|
||
);
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
if (autoPopulateSelections && !hasManualSelectionInput) {
|
||
const autoFilled = await this.autoPopulateWaveStrategyFetchSelections({
|
||
plan: effectivePlan,
|
||
strategyRow: effectivePlan.strategy_row,
|
||
waveBatchSource,
|
||
transaction,
|
||
});
|
||
|
||
effectivePlan = {
|
||
...effectivePlan,
|
||
selected_wave_ids: autoFilled.selected_wave_ids,
|
||
box_assignments: this.buildWaveStrategyFetchBoxAssignments({
|
||
pickMode,
|
||
selectedWaveIds: autoFilled.selected_wave_ids,
|
||
boxLimit: Number(effectivePlan.box_limit || 0),
|
||
}),
|
||
};
|
||
effectiveRequestData = {
|
||
...effectiveRequestData,
|
||
selected_wave_ids: autoFilled.selected_wave_ids,
|
||
selected_order_ids: autoFilled.selected_order_ids,
|
||
};
|
||
}
|
||
|
||
const selectedWaveIds = this.normalizeIdsInput(effectivePlan.selected_wave_ids || []);
|
||
const selectedOrderIds = this.normalizeIdsInput(
|
||
effectiveRequestData.selected_order_ids !== undefined
|
||
? effectiveRequestData.selected_order_ids
|
||
: effectiveRequestData.selectedOrderIds !== undefined
|
||
? effectiveRequestData.selectedOrderIds
|
||
: effectiveRequestData.order_ids !== undefined
|
||
? effectiveRequestData.order_ids
|
||
: effectiveRequestData.orderIds
|
||
);
|
||
|
||
const validationErrors = Array.isArray(effectivePlan.validation_errors)
|
||
? [ ...effectivePlan.validation_errors ]
|
||
: [];
|
||
if ([ 1, 5 ].includes(pickMode) && selectedWaveIds.length === 0) {
|
||
validationErrors.push('当前模式依赖波次,selected_wave_ids 不能为空');
|
||
}
|
||
if ([ 2, 3, 4 ].includes(pickMode) && selectedOrderIds.length === 0) {
|
||
validationErrors.push('当前模式至少需要一个订单,selected_order_ids 不能为空');
|
||
}
|
||
if (validationErrors.length > 0) {
|
||
throw new Error(`按策略抓取任务创建校验失败: ${validationErrors.join(';')}`);
|
||
}
|
||
|
||
if (normalizedCartId > 0) {
|
||
await this.ensurePickCartAvailable({
|
||
cartId: normalizedCartId,
|
||
warehouseId,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
// 散单模式:从波次表读取 wave_no 并写入任务 batch_no
|
||
let resolvedBatchNo = null;
|
||
if ([ 2, 3, 4 ].includes(pickMode) && selectedWaveIds.length > 0) {
|
||
const batchRows = await this.ctx.model.query(
|
||
'SELECT wave_no FROM wms_wave_batch WHERE wave_id = :waveId AND warehouse_id = :warehouseId LIMIT 1',
|
||
{
|
||
replacements: { waveId: selectedWaveIds[0], warehouseId },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
resolvedBatchNo = (batchRows.length > 0 && batchRows[0].wave_no) ? String(batchRows[0].wave_no).trim() : null;
|
||
}
|
||
|
||
const taskPayload = this.buildTaskCreatePayload({
|
||
plan: effectivePlan,
|
||
data: effectiveRequestData,
|
||
selectedWaveIds,
|
||
selectedOrderIds,
|
||
cartId: normalizedCartId,
|
||
});
|
||
if (resolvedBatchNo !== null) {
|
||
taskPayload.batch_no = resolvedBatchNo;
|
||
}
|
||
|
||
if (selectedWaveIds.length > 0 && [ 1, 2 ].includes(waveBatchSource)) {
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_batch
|
||
SET source = :source,
|
||
update_time = NOW()
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
`, {
|
||
replacements: {
|
||
source: waveBatchSource,
|
||
warehouseId,
|
||
waveIds: selectedWaveIds,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
const taskCreateResult = await this.createWavePickTaskWithRetry(taskPayload, transaction);
|
||
const taskId = Number(taskCreateResult.task_id || 0);
|
||
const taskNo = String(taskCreateResult.task_no || '').trim();
|
||
|
||
// 查询所有选中波次的 wave_no,用于填充任务波次关联记录
|
||
const waveNoMap = new Map();
|
||
if (selectedWaveIds.length > 0) {
|
||
const waveNoRows = await this.ctx.model.query(
|
||
`SELECT wave_id, wave_no
|
||
FROM wms_wave_batch
|
||
WHERE wave_id IN (:waveIds)
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { waveIds: selectedWaveIds, warehouseId },
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
for (const row of Array.isArray(waveNoRows) ? waveNoRows : []) {
|
||
const wid = Number(row && row.wave_id || 0);
|
||
const wno = String(row && row.wave_no || '').trim();
|
||
if (wid > 0 && wno) {
|
||
waveNoMap.set(wid, wno);
|
||
}
|
||
}
|
||
}
|
||
|
||
const taskWaveRows = this.buildTaskWaveRows({
|
||
taskId,
|
||
plan: effectivePlan,
|
||
selectedWaveIds,
|
||
waveNoMap,
|
||
});
|
||
// 查询波次索引(wave_index),使 box_no 与 wms_order_wave_index.wave_index 一致
|
||
const waveIndexMap = new Map();
|
||
if (selectedOrderIds.length > 0 && selectedWaveIds.length > 0) {
|
||
try {
|
||
const waveIndexRows = await this.ctx.model.query(
|
||
`SELECT order_id, wave_index
|
||
FROM wms_order_wave_index
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
AND order_id IN (:orderIds)`,
|
||
{
|
||
replacements: {
|
||
warehouseId,
|
||
waveIds: selectedWaveIds,
|
||
orderIds: selectedOrderIds,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
for (const wr of (Array.isArray(waveIndexRows) ? waveIndexRows : [])) {
|
||
const wrOrderId = Number(wr && wr.order_id || 0);
|
||
if (wrOrderId > 0) {
|
||
waveIndexMap.set(wrOrderId, Number(wr.wave_index || 0));
|
||
}
|
||
}
|
||
} catch (e) {
|
||
this.ctx.logger.warn('[wave.createTask] 查询波次索引失败,box_no 将退化为任务内序号', {
|
||
error: e && e.message,
|
||
warehouseId,
|
||
waveIds: selectedWaveIds,
|
||
});
|
||
}
|
||
}
|
||
|
||
const taskOrderRows = this.buildTaskOrderRows({
|
||
taskId,
|
||
plan: effectivePlan,
|
||
selectedWaveIds,
|
||
selectedOrderIds,
|
||
cartId: normalizedCartId,
|
||
waveIndexMap,
|
||
});
|
||
const taskSkuRows = await this.buildTaskSkuRows({
|
||
plan: effectivePlan,
|
||
selectedOrderIds,
|
||
});
|
||
const taskBoxRows = this.buildTaskBoxRows({
|
||
taskId,
|
||
taskNo,
|
||
plan: effectivePlan,
|
||
taskWaveRows,
|
||
taskOrderRows,
|
||
taskSkuRows,
|
||
});
|
||
|
||
if (taskWaveRows.length > 0) {
|
||
await this.bulkInsertRows('wms_wave_pick_task_wave', taskWaveRows, transaction);
|
||
}
|
||
if (taskOrderRows.length > 0) {
|
||
await this.bulkInsertRows('wms_wave_pick_task_order', taskOrderRows, transaction);
|
||
}
|
||
if (taskBoxRows.length > 0) {
|
||
await this.bulkInsertRows('wms_wave_pick_task_box', taskBoxRows, transaction);
|
||
}
|
||
|
||
if (normalizedCartId > 0) {
|
||
await this.bindPickCartForTask({
|
||
taskId,
|
||
cartId: normalizedCartId,
|
||
warehouseId,
|
||
operatorId: taskPayload.pick_user_id,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
await this.initTaskCheckpointAndLogs({
|
||
taskId,
|
||
taskNo,
|
||
plan: effectivePlan,
|
||
data: effectiveRequestData,
|
||
selectedOrderIds,
|
||
cartId: normalizedCartId,
|
||
operatorId: taskPayload.pick_user_id,
|
||
operatorName: taskPayload.pick_user_name,
|
||
transaction,
|
||
});
|
||
|
||
await transaction.commit();
|
||
|
||
// 写入订单操作日志:分配到波次
|
||
if (selectedOrderIds.length > 0) {
|
||
const waveNoList = taskWaveRows
|
||
.map(r => String(r && r.wave_no || '').trim())
|
||
.filter(Boolean);
|
||
const waveNoMessage = waveNoList.length > 0 ? waveNoList.join(',') : '';
|
||
await this.batchCreateOrderOperationLogs(
|
||
selectedOrderIds.map(orderId => ({
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_ASSIGN',
|
||
message: `分配到波次 ${waveNoMessage}`,
|
||
})),
|
||
{ warehouseId, scene: 'createWavePickTaskFromPlan' }
|
||
);
|
||
}
|
||
|
||
return {
|
||
task_id: taskId,
|
||
task_no: taskNo,
|
||
state: 'created',
|
||
plan_summary: {
|
||
pick_mode: pickMode,
|
||
wave_count: taskWaveRows.length,
|
||
order_count: taskOrderRows.length,
|
||
box_count: taskBoxRows.length,
|
||
cart_id: normalizedCartId > 0 ? normalizedCartId : null,
|
||
},
|
||
};
|
||
} catch (error) {
|
||
const errorDetail = {
|
||
name: String(error && error.name || ''),
|
||
message: String(error && error.message || ''),
|
||
stack: String(error && error.stack || '').split('\n').slice(0, 6)
|
||
.join('\n'),
|
||
sql: String(error && error.sql || '').slice(0, 500),
|
||
errorType: Object.prototype.toString.call(error),
|
||
errors: Array.isArray(error && error.errors)
|
||
? error.errors.map(e => ({ message: e.message, type: e.type, path: e.path, value: e.value }))
|
||
: [],
|
||
};
|
||
this.ctx.logger.error('[wave.createWavePickTaskFromPlan] 任务创建异常详情', errorDetail);
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 构建任务主表写入载荷。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {Object} options.plan 预处理计划。
|
||
* @param {Object} options.data 原始请求数据。
|
||
* @param {Array<number>} options.selectedWaveIds 已选波次ID。
|
||
* @param {Array<number>} options.selectedOrderIds 已选订单ID。
|
||
* @param {number} options.cartId 拣货车ID。
|
||
* @return {Object} 主表写入载荷。
|
||
*/
|
||
buildTaskCreatePayload(options = {}) {
|
||
const plan = this.isPlainObject(options && options.plan) ? options.plan : {};
|
||
const data = this.isPlainObject(options && options.data) ? options.data : {};
|
||
const selectedWaveIds = Array.isArray(options && options.selectedWaveIds)
|
||
? options.selectedWaveIds
|
||
: [];
|
||
const selectedOrderIds = Array.isArray(options && options.selectedOrderIds)
|
||
? options.selectedOrderIds
|
||
: [];
|
||
const pickMode = this.normalizeRequiredPositiveInteger(plan.pick_mode, 'pick_mode');
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const source = String(plan.source || 'unknown').trim();
|
||
const sourceCode = source === 'admin' ? 2 : 1;
|
||
|
||
const operator = this.isPlainObject(plan.operator) ? plan.operator : {};
|
||
const rawOperatorId = operator.operator_id ?? operator.id;
|
||
const normalizedOperatorId = Number(rawOperatorId);
|
||
const pickUserId = Number.isInteger(normalizedOperatorId) && normalizedOperatorId >= 0
|
||
? normalizedOperatorId
|
||
: 0;
|
||
const pickUserName = String(operator.operator_name || operator.name || this.getOrderLogOperator().name || 'system').trim() || 'system';
|
||
const taskNo = String(data.task_no || '').trim() || this.generateWavePickTaskNo(warehouseId, sourceCode);
|
||
|
||
return {
|
||
task_no: taskNo,
|
||
warehouse_id: warehouseId,
|
||
wave_id: selectedWaveIds.length > 0 ? selectedWaveIds[0] : null,
|
||
pick_mode: pickMode,
|
||
status: 0,
|
||
source: sourceCode,
|
||
wave_count: selectedWaveIds.length,
|
||
order_count: selectedOrderIds.length,
|
||
box_count: 0,
|
||
batch_no: null,
|
||
pick_user_id: pickUserId,
|
||
pick_user_name: pickUserName,
|
||
current_cart_id: Number(options && options.cartId || 0) > 0 ? Number(options.cartId) : null,
|
||
current_cart_code_snapshot: null,
|
||
review_status: 0,
|
||
review_version: 0,
|
||
device_id: String(data.device_id || data.deviceId || '').trim() || `wave_${source}_${warehouseId}`,
|
||
ext_json: JSON.stringify({
|
||
strategy_id: plan.strategy_id,
|
||
wave_limit: Number(plan.wave_limit || 0),
|
||
order_limit: Number(plan.order_limit || 0),
|
||
sku_limit: Number(plan.sku_limit || 0),
|
||
box_limit: Number(plan.box_limit || 0),
|
||
dynamic_append: Boolean(plan.dynamic_append),
|
||
}),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建任务波次关联写入行。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {number} options.taskId 任务ID。
|
||
* @param {Object} options.plan 预处理计划。
|
||
* @param {Array<number>} options.selectedWaveIds 已选波次ID。
|
||
* @param {Map<number, string>} [options.waveNoMap] wave_id → wave_no 映射。
|
||
* @return {Array<Object>} 任务波次关联行。
|
||
*/
|
||
buildTaskWaveRows(options = {}) {
|
||
const taskId = Number(options && options.taskId || 0);
|
||
const plan = this.isPlainObject(options && options.plan) ? options.plan : {};
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const selectedWaveIds = Array.isArray(options && options.selectedWaveIds)
|
||
? options.selectedWaveIds
|
||
: [];
|
||
const waveNoMap = options && options.waveNoMap instanceof Map
|
||
? options.waveNoMap
|
||
: new Map();
|
||
|
||
return selectedWaveIds.map((waveId, index) => ({
|
||
task_id: taskId,
|
||
wave_id: waveId,
|
||
wave_no: waveNoMap.get(waveId) || null,
|
||
box_no: index + 1,
|
||
status: 0,
|
||
bind_time: null,
|
||
pick_time: null,
|
||
warehouse_id: warehouseId,
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 构建任务订单明细写入行。
|
||
*
|
||
* box_no 与 wms_order_wave_index.wave_index 保持一致(波次内全局顺序)。
|
||
* 若 waveIndexMap 中无对应记录,则退化为当前订单在 selectedOrderIds 中的 index + 1。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {number} options.taskId 任务ID。
|
||
* @param {Object} options.plan 预处理计划。
|
||
* @param {Array<number>} options.selectedWaveIds 已选波次ID。
|
||
* @param {Array<number>} options.selectedOrderIds 已选订单ID。
|
||
* @param {number} options.cartId 绑定车ID。
|
||
* @param {Map<number, number>} [options.waveIndexMap] orderId → wave_index 映射。
|
||
* @return {Array<Object>} 任务订单行。
|
||
*/
|
||
buildTaskOrderRows(options = {}) {
|
||
const taskId = Number(options && options.taskId || 0);
|
||
const plan = this.isPlainObject(options && options.plan) ? options.plan : {};
|
||
const pickMode = Number(plan.pick_mode || 0);
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const selectedWaveIds = Array.isArray(options && options.selectedWaveIds)
|
||
? options.selectedWaveIds
|
||
: [];
|
||
const selectedOrderIds = Array.isArray(options && options.selectedOrderIds)
|
||
? options.selectedOrderIds
|
||
: [];
|
||
const cartId = Number(options && options.cartId || 0);
|
||
const waveIndexMap = options && options.waveIndexMap instanceof Map
|
||
? options.waveIndexMap
|
||
: new Map();
|
||
|
||
if (![ 2, 3, 4 ].includes(pickMode)) {
|
||
return [];
|
||
}
|
||
|
||
const defaultWaveId = selectedWaveIds.length > 0 ? selectedWaveIds[0] : null;
|
||
return selectedOrderIds.map((orderId, index) => {
|
||
const waveIndex = waveIndexMap.has(orderId)
|
||
? Number(waveIndexMap.get(orderId) || 0)
|
||
: 0;
|
||
return {
|
||
task_id: taskId,
|
||
wave_id: defaultWaveId,
|
||
order_id: orderId,
|
||
order_no: null,
|
||
box_no: waveIndex > 0 ? waveIndex : (index + 1),
|
||
cart_id: cartId > 0 ? cartId : null,
|
||
cart_code_snapshot: null,
|
||
warehouse_id: warehouseId,
|
||
pick_status: 0,
|
||
review_status: 0,
|
||
review_user_id: null,
|
||
review_result: null,
|
||
review_remark: null,
|
||
exception_reason: null,
|
||
picked_time: null,
|
||
review_time: null,
|
||
};
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 构建任务 SKU 明细写入行(仅先拣后分模式使用)。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {Object} options.plan 预处理计划。
|
||
* @param {Array<number>} options.selectedOrderIds 已选订单ID。
|
||
* @return {Promise<Array<Object>>} 任务 SKU 行。
|
||
*/
|
||
async buildTaskSkuRows(options = {}) {
|
||
const plan = this.isPlainObject(options && options.plan) ? options.plan : {};
|
||
const pickMode = Number(plan.pick_mode || 0);
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const selectedOrderIds = Array.isArray(options && options.selectedOrderIds)
|
||
? this.normalizeIdsInput(options.selectedOrderIds)
|
||
: [];
|
||
|
||
if (pickMode !== 3 || selectedOrderIds.length <= 0) {
|
||
return [];
|
||
}
|
||
|
||
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
|
||
if (!orderItemsModel || typeof orderItemsModel.findAll !== 'function') {
|
||
throw new Error('订单明细模型不可用');
|
||
}
|
||
|
||
const itemRows = await orderItemsModel.findAll({
|
||
where: {
|
||
order_id: { [Op.in]: selectedOrderIds },
|
||
},
|
||
attributes: [ 'order_id', 'plan_qty', 'stock_id', 'item_code', 'item_name', 'item_snapshot' ],
|
||
raw: true,
|
||
});
|
||
|
||
const skuMap = new Map();
|
||
for (const row of (Array.isArray(itemRows) ? itemRows : [])) {
|
||
const normalized = this.normalizeOrderItemRow(row);
|
||
if (normalized.quantity <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const skuId = Number(normalized.stock_id || 0);
|
||
const itemCode = String(normalized.item_code || '').trim();
|
||
const itemName = String(normalized.item_name || '').trim();
|
||
if (!(Number.isInteger(skuId) && skuId > 0) && !itemCode) {
|
||
continue;
|
||
}
|
||
|
||
const key = Number.isInteger(skuId) && skuId > 0 ? `stock_${skuId}` : `code_${itemCode}`;
|
||
if (!skuMap.has(key)) {
|
||
skuMap.set(key, {
|
||
sku_id: Number.isInteger(skuId) && skuId > 0 ? skuId : null,
|
||
ref_id: Number.isInteger(skuId) && skuId > 0 ? skuId : null,
|
||
ref_label: itemName || itemCode || null,
|
||
required_qty: 0,
|
||
});
|
||
}
|
||
|
||
const aggregated = skuMap.get(key);
|
||
aggregated.required_qty += normalized.quantity;
|
||
if (!aggregated.ref_label && (itemName || itemCode)) {
|
||
aggregated.ref_label = itemName || itemCode;
|
||
}
|
||
}
|
||
|
||
return Array.from(skuMap.values())
|
||
.sort((a, b) => {
|
||
const leftSkuId = Number(a.sku_id || 0);
|
||
const rightSkuId = Number(b.sku_id || 0);
|
||
if (leftSkuId !== rightSkuId) {
|
||
return leftSkuId - rightSkuId;
|
||
}
|
||
return String(a.ref_label || '').localeCompare(String(b.ref_label || ''));
|
||
})
|
||
.map((row, index) => ({
|
||
box_no: index + 1,
|
||
sku_id: row.sku_id,
|
||
ref_id: row.ref_id,
|
||
ref_label: row.ref_label,
|
||
required_qty: Number(row.required_qty || 0),
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 构建任务框明细写入行。
|
||
*
|
||
* @param {Object} options 构建参数。
|
||
* @param {number} options.taskId 任务ID。
|
||
* @param {string} options.taskNo 任务编号。
|
||
* @param {Object} options.plan 预处理计划。
|
||
* @param {Array<Object>} options.taskWaveRows 任务波次行。
|
||
* @param {Array<Object>} options.taskOrderRows 任务订单行。
|
||
* @param {Array<Object>} options.taskSkuRows 任务 SKU 行。
|
||
* @return {Array<Object>} 任务框行。
|
||
*/
|
||
buildTaskBoxRows(options = {}) {
|
||
const taskId = Number(options && options.taskId || 0);
|
||
const taskNo = String(options && options.taskNo || '').trim();
|
||
const plan = this.isPlainObject(options && options.plan) ? options.plan : {};
|
||
const pickMode = Number(plan.pick_mode || 0);
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const taskWaveRows = Array.isArray(options && options.taskWaveRows)
|
||
? options.taskWaveRows
|
||
: [];
|
||
const taskOrderRows = Array.isArray(options && options.taskOrderRows)
|
||
? options.taskOrderRows
|
||
: [];
|
||
const taskSkuRows = Array.isArray(options && options.taskSkuRows)
|
||
? options.taskSkuRows
|
||
: [];
|
||
|
||
if ([ 1, 5 ].includes(pickMode)) {
|
||
return taskWaveRows.map(row => ({
|
||
task_id: taskId,
|
||
order_id: null,
|
||
box_code: `${taskNo || taskId}-W${row.box_no}`,
|
||
box_no: row.box_no,
|
||
box_type: 3,
|
||
ref_id: row.wave_id,
|
||
ref_label: row.wave_no,
|
||
required_qty: 0,
|
||
picked_qty: 0,
|
||
box_status: 0,
|
||
review_result: null,
|
||
review_user_id: null,
|
||
review_time: null,
|
||
warehouse_id: warehouseId,
|
||
}));
|
||
}
|
||
|
||
if (pickMode === 3 && taskSkuRows.length > 0) {
|
||
return taskSkuRows.map(row => ({
|
||
task_id: taskId,
|
||
order_id: null,
|
||
box_code: `${taskNo || taskId}-S${row.box_no}`,
|
||
box_no: row.box_no,
|
||
box_type: 1,
|
||
ref_id: Number(row.ref_id || row.sku_id || 0) || null,
|
||
ref_label: String(row.ref_label || '').trim() || null,
|
||
required_qty: Number(row.required_qty || 0),
|
||
picked_qty: 0,
|
||
box_status: 0,
|
||
review_result: null,
|
||
review_user_id: null,
|
||
review_time: null,
|
||
warehouse_id: warehouseId,
|
||
}));
|
||
}
|
||
|
||
return taskOrderRows.map(row => ({
|
||
task_id: taskId,
|
||
order_id: row.order_id,
|
||
box_code: `${taskNo || taskId}-O${row.box_no}`,
|
||
box_no: row.box_no,
|
||
box_type: 2,
|
||
ref_id: row.order_id,
|
||
ref_label: null,
|
||
required_qty: 0,
|
||
picked_qty: 0,
|
||
box_status: 0,
|
||
review_result: null,
|
||
review_user_id: null,
|
||
review_time: null,
|
||
warehouse_id: warehouseId,
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 领单时绑定拣货车并更新车辆主表。
|
||
*
|
||
* @param {Object} params 绑定参数。
|
||
* @param {number} params.taskId 任务ID。
|
||
* @param {number} params.cartId 拣货车ID。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {number} params.operatorId 操作人ID。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async bindPickCartForTask(params = {}) {
|
||
const taskId = this.normalizeRequiredPositiveInteger(params.taskId, 'task_id');
|
||
const cartId = this.normalizeRequiredPositiveInteger(params.cartId, 'cart_id');
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const transaction = params.transaction;
|
||
const operatorId = Number.isInteger(Number(params.operatorId))
|
||
? Number(params.operatorId)
|
||
: 0;
|
||
|
||
const cartRows = await this.ctx.model.query(`
|
||
SELECT id, cart_code
|
||
FROM wms_pick_cart
|
||
WHERE id = :cartId
|
||
AND warehouse_id = :warehouseId
|
||
AND status = 1
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
cartId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const cartRow = Array.isArray(cartRows) ? cartRows[0] : null;
|
||
if (!cartRow) {
|
||
throw new Error(`拣货车不存在或已停用: ${cartId}`);
|
||
}
|
||
|
||
// 通过绑定表判断车是否被其他活跃任务占用(不依赖 wms_pick_cart.current_task_id)
|
||
// 仅以 wms_pick_task_cart_binding.is_active = 1 为准,不关联任务状态做二次过滤
|
||
const bindingRows = await this.ctx.model.query(`
|
||
SELECT b.task_id
|
||
FROM wms_pick_task_cart_binding b
|
||
WHERE b.cart_id = :cartId
|
||
AND b.warehouse_id = :warehouseId
|
||
AND b.is_active = 1
|
||
LIMIT 1
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
cartId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const activeBindingTaskId = Number(
|
||
(Array.isArray(bindingRows) && bindingRows.length > 0 ? bindingRows[0]?.task_id : 0)
|
||
);
|
||
if (activeBindingTaskId > 0 && activeBindingTaskId !== taskId) {
|
||
throw new Error(`拣货车已被活动任务占用: ${cartId}`);
|
||
}
|
||
|
||
await this.bulkInsertRows('wms_pick_task_cart_binding', [{
|
||
task_id: taskId,
|
||
cart_id: cartId,
|
||
cart_code_snapshot: String(cartRow.cart_code || '').trim() || null,
|
||
warehouse_id: warehouseId,
|
||
bind_user_id: operatorId,
|
||
bind_type: 1,
|
||
unbind_user_id: null,
|
||
is_active: 1,
|
||
bind_time: new Date(),
|
||
unbind_time: null,
|
||
}], transaction);
|
||
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_pick_task
|
||
SET
|
||
current_cart_id = :cartId,
|
||
current_cart_code_snapshot = :cartCode
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
cartId,
|
||
cartCode: String(cartRow.cart_code || '').trim() || null,
|
||
warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 初始化任务断点、动作日志与轨迹。
|
||
*
|
||
* @param {Object} params 初始化参数。
|
||
* @param {number} params.taskId 任务ID。
|
||
* @param {string} params.taskNo 任务编号。
|
||
* @param {Object} params.plan 预处理计划。
|
||
* @param {Object} params.data 原始请求数据。
|
||
* @param {Array<number>} params.selectedOrderIds 已选订单ID。
|
||
* @param {number} params.cartId 绑定车ID。
|
||
* @param {number} params.operatorId 操作人ID。
|
||
* @param {string} params.operatorName 操作人姓名。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async initTaskCheckpointAndLogs(params = {}) {
|
||
const taskId = this.normalizeRequiredPositiveInteger(params.taskId, 'task_id');
|
||
const taskNo = String(params.taskNo || '').trim();
|
||
const plan = this.isPlainObject(params.plan) ? params.plan : {};
|
||
const data = this.isPlainObject(params.data) ? params.data : {};
|
||
const transaction = params.transaction;
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
|
||
const operatorId = Number.isInteger(Number(params.operatorId))
|
||
? Number(params.operatorId)
|
||
: 0;
|
||
const operatorName = String(params.operatorName || 'system').trim() || 'system';
|
||
const cartId = Number(params.cartId || 0) > 0 ? Number(params.cartId) : null;
|
||
const selectedOrderIds = Array.isArray(params.selectedOrderIds) && params.selectedOrderIds.length > 0
|
||
? params.selectedOrderIds
|
||
: [ 0 ];
|
||
const deviceId = String(data.device_id || data.deviceId || '').trim() || `device_${warehouseId}`;
|
||
const requestId = String(data.request_id || data.requestId || `${taskNo || taskId}_init`).trim();
|
||
|
||
await this.bulkInsertRows('wms_wave_pick_checkpoint', [{
|
||
task_id: taskId,
|
||
warehouse_id: warehouseId,
|
||
pick_user_id: operatorId,
|
||
device_id: deviceId,
|
||
current_location_id: null,
|
||
current_sku_id: null,
|
||
current_box_no: null,
|
||
picked_count: 0,
|
||
remaining_count: Math.max(selectedOrderIds.length, 0),
|
||
last_event_id: null,
|
||
last_seq_no: null,
|
||
checkpoint_json: JSON.stringify({
|
||
state: 'created',
|
||
task_no: taskNo,
|
||
}),
|
||
version: 0,
|
||
}], transaction);
|
||
|
||
await this.bulkInsertRows('wms_wave_pick_action_log', [{
|
||
task_id: taskId,
|
||
warehouse_id: warehouseId,
|
||
wave_id: Array.isArray(plan.selected_wave_ids) && plan.selected_wave_ids.length > 0
|
||
? Number(plan.selected_wave_ids[0])
|
||
: null,
|
||
order_id: selectedOrderIds[0],
|
||
sku_id: null,
|
||
location_id: null,
|
||
box_no: null,
|
||
cart_id: cartId,
|
||
qty_delta: 0,
|
||
action_type: 'init',
|
||
request_id: `${requestId}_${taskId}`,
|
||
operator_id: operatorId,
|
||
device_id: deviceId,
|
||
seq_no: 1,
|
||
snapshot: JSON.stringify({
|
||
task_no: taskNo,
|
||
state: 'created',
|
||
}),
|
||
}], transaction);
|
||
|
||
const traceRows = selectedOrderIds.map(orderId => ({
|
||
warehouse_id: warehouseId,
|
||
order_id: Number(orderId),
|
||
task_id: taskId,
|
||
cart_id: cartId,
|
||
cart_code_snapshot: null,
|
||
pick_user_id: operatorId,
|
||
pick_time: null,
|
||
review_user_id: null,
|
||
review_time: null,
|
||
review_result: null,
|
||
event_type: 'task_created',
|
||
event_desc: `任务创建: ${taskNo || taskId}`,
|
||
operator_id: operatorId,
|
||
operator_name: operatorName,
|
||
snapshot: JSON.stringify({
|
||
task_no: taskNo,
|
||
pick_mode: Number(plan.pick_mode || 0),
|
||
}),
|
||
}));
|
||
await this.bulkInsertRows('wms_order_pick_trace', traceRows, transaction);
|
||
}
|
||
|
||
/**
|
||
* 校验拣货车是否可占用。
|
||
*
|
||
* @param {Object} params 校验参数。
|
||
* @param {number} params.cartId 拣货车ID。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {Object} params.transaction 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async ensurePickCartAvailable(params = {}) {
|
||
const cartId = this.normalizeRequiredPositiveInteger(params.cartId, 'cart_id');
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
|
||
const transaction = params.transaction;
|
||
|
||
const rows = await this.ctx.model.query(`
|
||
SELECT b.task_id
|
||
FROM wms_pick_task_cart_binding b
|
||
INNER JOIN wms_wave_pick_task t ON t.id = b.task_id
|
||
WHERE b.cart_id = :cartId
|
||
AND b.warehouse_id = :warehouseId
|
||
AND b.is_active = 1
|
||
AND t.status IN (0, 1)
|
||
LIMIT 1
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
cartId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
if (Array.isArray(rows) && rows.length > 0) {
|
||
throw new Error(`拣货车已绑定活动任务: ${cartId}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成任务编号。
|
||
*
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {number} sourceCode 来源编码。
|
||
* @return {string} 任务编号。
|
||
*/
|
||
generateWavePickTaskNo(warehouseId, sourceCode) {
|
||
const now = Date.now();
|
||
const rand = Math.random().toString(36).slice(2, 8)
|
||
.toUpperCase();
|
||
return `WPT${warehouseId}${sourceCode}${now}${rand}`;
|
||
}
|
||
|
||
/**
|
||
* 写入任务主表并在任务编号冲突时重试。
|
||
*
|
||
* @param {Object} payload 主表载荷。
|
||
* @param {Object} transaction 事务对象。
|
||
* @return {Promise<{ task_id: number, task_no: string }>} 主表写入结果。
|
||
*/
|
||
async createWavePickTaskWithRetry(payload = {}, transaction) {
|
||
const maxRetry = 5;
|
||
const warehouseId = this.normalizeRequiredPositiveInteger(payload.warehouse_id, 'warehouse_id');
|
||
|
||
for (let attempt = 1; attempt <= maxRetry; attempt += 1) {
|
||
const candidateTaskNo = attempt === 1 && String(payload.task_no || '').trim()
|
||
? String(payload.task_no || '').trim()
|
||
: this.generateWavePickTaskNo(warehouseId, Number(payload.source || 1));
|
||
|
||
const insertPayload = {
|
||
...payload,
|
||
task_no: candidateTaskNo,
|
||
};
|
||
|
||
try {
|
||
const createResult = await this.ctx.model.query(`
|
||
INSERT INTO wms_wave_pick_task
|
||
(
|
||
task_no,
|
||
warehouse_id,
|
||
wave_id,
|
||
pick_mode,
|
||
status,
|
||
source,
|
||
wave_count,
|
||
order_count,
|
||
box_count,
|
||
batch_no,
|
||
pick_user_id,
|
||
pick_user_name,
|
||
current_cart_id,
|
||
current_cart_code_snapshot,
|
||
review_status,
|
||
review_version,
|
||
device_id,
|
||
ext_json,
|
||
create_time,
|
||
update_time
|
||
)
|
||
VALUES
|
||
(
|
||
:task_no,
|
||
:warehouse_id,
|
||
:wave_id,
|
||
:pick_mode,
|
||
:status,
|
||
:source,
|
||
:wave_count,
|
||
:order_count,
|
||
:box_count,
|
||
:batch_no,
|
||
:pick_user_id,
|
||
:pick_user_name,
|
||
:current_cart_id,
|
||
:current_cart_code_snapshot,
|
||
:review_status,
|
||
:review_version,
|
||
:device_id,
|
||
:ext_json,
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`, {
|
||
replacements: insertPayload,
|
||
transaction,
|
||
});
|
||
|
||
let insertedTaskId = this.extractInsertId(createResult);
|
||
if (!Number.isInteger(insertedTaskId) || insertedTaskId <= 0) {
|
||
const fallbackResult = await this.ctx.model.query('SELECT LAST_INSERT_ID() AS insertId', {
|
||
transaction,
|
||
});
|
||
insertedTaskId = this.extractLastInsertId(fallbackResult);
|
||
}
|
||
|
||
if (!Number.isInteger(insertedTaskId) || insertedTaskId <= 0) {
|
||
throw new Error('创建任务失败,未获取到任务主键');
|
||
}
|
||
|
||
return {
|
||
task_id: insertedTaskId,
|
||
task_no: candidateTaskNo,
|
||
};
|
||
} catch (error) {
|
||
const isDuplicateTaskNo = this.isTaskNoDuplicateError(error);
|
||
if (isDuplicateTaskNo && attempt < maxRetry) {
|
||
continue;
|
||
}
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
throw new Error('创建任务失败,任务编号重试次数已达上限');
|
||
}
|
||
|
||
/**
|
||
* 判断是否为 task_no 唯一键冲突。
|
||
*
|
||
* @param {Error} error 数据库错误。
|
||
* @return {boolean} 是否冲突。
|
||
*/
|
||
isTaskNoDuplicateError(error) {
|
||
const message = String(error && error.message || '').toLowerCase();
|
||
const parentErrno = Number(error && error.parent && error.parent.errno || 0);
|
||
return parentErrno === 1062
|
||
|| message.includes('duplicate entry')
|
||
|| message.includes('uk_task_no');
|
||
}
|
||
|
||
/**
|
||
* 批量插入行数据。
|
||
*
|
||
* @param {string} tableName 表名。
|
||
* @param {Array<Object>} rows 行数据。
|
||
* @param {Object} transaction 事务对象。
|
||
* @return {Promise<number>} 实际写入行数。
|
||
*/
|
||
async bulkInsertRows(tableName, rows = [], transaction) {
|
||
if (!Array.isArray(rows) || rows.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
const columns = Object.keys(rows[0]);
|
||
if (columns.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
const replacements = {};
|
||
const valueSqlList = rows.map((row, rowIndex) => {
|
||
const placeholders = columns.map(column => {
|
||
const key = `${column}_${rowIndex}`;
|
||
replacements[key] = Object.prototype.hasOwnProperty.call(row, column)
|
||
? row[column]
|
||
: null;
|
||
return `:${key}`;
|
||
});
|
||
return `(${placeholders.join(', ')})`;
|
||
});
|
||
|
||
const columnSql = columns.map(column => `\`${column}\``).join(', ');
|
||
const sql = `INSERT INTO ${tableName} (${columnSql}) VALUES ${valueSqlList.join(', ')}`;
|
||
await this.ctx.model.query(sql, {
|
||
replacements,
|
||
transaction,
|
||
});
|
||
|
||
return rows.length;
|
||
}
|
||
|
||
/**
|
||
* 解析“存在未完成任务”异常信息中的任务标识。
|
||
*
|
||
* @param {string} message 异常消息文本。
|
||
* @return {{ task_id: number|null, task_no: string|null }} 解析结果。
|
||
*/
|
||
parseWaveStrategyExistingTaskInfo(message = '') {
|
||
const normalizedMessage = String(message || '');
|
||
const match = normalizedMessage.match(/task_id=(\d+)(?:,task_no=([^\)\)\s]+))?/);
|
||
if (!match) {
|
||
return {
|
||
task_id: null,
|
||
task_no: null,
|
||
};
|
||
}
|
||
|
||
const parsedTaskId = Number(match[1] || 0);
|
||
const parsedTaskNo = String(match[2] || '').trim();
|
||
|
||
return {
|
||
task_id: Number.isInteger(parsedTaskId) && parsedTaskId > 0 ? parsedTaskId : null,
|
||
task_no: parsedTaskNo || null,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 按策略抓取任务壳子方法(仅 PDA 使用),仅受理请求并返回任务信息。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {number|string} data.strategy_id 波次策略ID(支持 strategyId)。
|
||
* @return {Promise<Object>} 受理结果。
|
||
*/
|
||
async waveStrategyFetchPda(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
const strategyId = this.normalizeRequiredPositiveInteger(
|
||
normalizedData.strategy_id ?? normalizedData.strategyId,
|
||
'strategy_id'
|
||
);
|
||
|
||
let warehouseId;
|
||
try {
|
||
warehouseId = Number(this.getWarehouseId());
|
||
} catch (error) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const operatorInfo = this.getOrderLogOperator();
|
||
const plan = await this.prepareWaveStrategyFetchPlan({
|
||
strategyId,
|
||
warehouseId,
|
||
operator: {
|
||
operator_id: operatorInfo.id,
|
||
operator_name: operatorInfo.name,
|
||
},
|
||
source: 'pda',
|
||
data: normalizedData,
|
||
});
|
||
|
||
if (Array.isArray(plan.validation_errors) && plan.validation_errors.length > 0) {
|
||
return this.fail('按策略抓取预处理校验失败', {
|
||
data: {
|
||
status: 'failed',
|
||
fetch_state: 2,
|
||
tip: '创建失败,请重试',
|
||
task_id: null,
|
||
can_enter_pick_flow: false,
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'pda',
|
||
plan,
|
||
},
|
||
}, 400);
|
||
}
|
||
|
||
try {
|
||
const createdTask = await this.createWavePickTaskFromPlan({
|
||
plan,
|
||
data: normalizedData,
|
||
waveBatchSource: 2,
|
||
autoPopulateSelections: true,
|
||
});
|
||
|
||
this.ctx.logger.info('[wave.waveStrategyFetchPda] 任务创建成功', {
|
||
taskId: createdTask.task_id,
|
||
taskNo: createdTask.task_no,
|
||
warehouseId,
|
||
strategyId,
|
||
});
|
||
|
||
return this.success('ok', {
|
||
status: 'success',
|
||
fetch_state: 1,
|
||
tip: '任务创建成功',
|
||
task_id: createdTask.task_id,
|
||
task_no: createdTask.task_no,
|
||
can_enter_pick_flow: false,
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'pda',
|
||
state: createdTask.state,
|
||
plan,
|
||
plan_summary: createdTask.plan_summary,
|
||
accepted_at: new Date().toISOString(),
|
||
});
|
||
} catch (error) {
|
||
const errorMessage = String(error && error.message || '');
|
||
if (errorMessage.includes('当前用户存在未完成任务')) {
|
||
const existingTaskInfo = this.parseWaveStrategyExistingTaskInfo(errorMessage);
|
||
return this.success('存在未完成任务', {
|
||
status: 'failed',
|
||
fetch_state: 3,
|
||
tip: '存在未完成任务,已返回任务ID,可继续拣货',
|
||
task_id: existingTaskInfo.task_id,
|
||
task_no: existingTaskInfo.task_no,
|
||
can_enter_pick_flow: true,
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'pda',
|
||
plan,
|
||
});
|
||
}
|
||
|
||
return this.fail(`按策略抓取任务创建失败: ${error.message}`, {
|
||
data: {
|
||
status: 'failed',
|
||
fetch_state: 2,
|
||
tip: '创建失败,请重试',
|
||
task_id: null,
|
||
can_enter_pick_flow: false,
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'pda',
|
||
plan,
|
||
},
|
||
}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 公共拣货任务取消流程。
|
||
*
|
||
* 仅允许取消状态为 0/1/2/3 的任务。取消后会回收拣货车绑定。
|
||
*
|
||
* 按任务来源区分行为:
|
||
* - source=1(PDA 抓取):释放关联波次(清空订单 wave_id、删除 wms_wave_batch),
|
||
* 使订单可重新参与后续策略抓取;状态为 2/3 时还会回退拣货状态。
|
||
* - source=2(后台/扫描创建):不释放波次,仅作废任务(更新状态为 9、解绑拣货车)。
|
||
*
|
||
* @param {Object} [params={}] 取消参数。
|
||
* @param {Array<number>} params.taskIds 任务ID列表。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {number} params.operatorId 操作人ID。
|
||
* @param {string} params.operatorName 操作人名称。
|
||
* @param {number|null} [params.restrictCreatorId=null] 限制创建人ID。
|
||
* @return {Promise<Object>} 取消结果。
|
||
*/
|
||
async cancelWavePickTasksInternal(params = {}) {
|
||
const normalizedParams = this.isPlainObject(params) ? params : {};
|
||
const sourceTaskIds = Array.isArray(normalizedParams.taskIds) ? normalizedParams.taskIds : [];
|
||
const normalizedTaskIds = [ ...new Set(sourceTaskIds
|
||
.map(item => Number(item))
|
||
.filter(taskId => Number.isInteger(taskId) && taskId > 0)) ];
|
||
const warehouseId = Number(normalizedParams.warehouseId || 0);
|
||
const operatorId = Number(normalizedParams.operatorId || 0);
|
||
const operatorName = String(normalizedParams.operatorName || 'system').trim() || 'system';
|
||
const rawRestrictCreatorId = normalizedParams.restrictCreatorId;
|
||
const restrictCreatorId = rawRestrictCreatorId === null || rawRestrictCreatorId === undefined
|
||
? null
|
||
: Number(rawRestrictCreatorId);
|
||
|
||
if (normalizedTaskIds.length === 0) {
|
||
const error = new Error('task_ids 必须为非空数组');
|
||
error.statusCode = 400;
|
||
error.data = {};
|
||
throw error;
|
||
}
|
||
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
const error = new Error('未获取到仓库上下文');
|
||
error.statusCode = 400;
|
||
error.data = {};
|
||
throw error;
|
||
}
|
||
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
const error = new Error('未获取到操作人上下文');
|
||
error.statusCode = 400;
|
||
error.data = {};
|
||
throw error;
|
||
}
|
||
|
||
if (restrictCreatorId !== null && (!Number.isInteger(restrictCreatorId) || restrictCreatorId <= 0)) {
|
||
const error = new Error('取消任务创建人限制参数不合法');
|
||
error.statusCode = 400;
|
||
error.data = {};
|
||
throw error;
|
||
}
|
||
|
||
const transaction = await this.ctx.model.transaction();
|
||
|
||
try {
|
||
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
|
||
const canceledAtColumnRows = await this.ctx.model.query(`
|
||
SHOW COLUMNS FROM wms_wave_pick_task LIKE 'cancelled_at'
|
||
`, {
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
const hasCancelledAtColumn = Array.isArray(canceledAtColumnRows) && canceledAtColumnRows.length > 0;
|
||
const cancelledTaskNos = [];
|
||
const cancelOrderLogItems = [];
|
||
let hasReleasedWaves = false;
|
||
|
||
for (const taskId of normalizedTaskIds) {
|
||
const requestId = `wave_pick_task_cancel_${warehouseId}_${taskId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
|
||
const taskRows = await this.ctx.model.query(`
|
||
SELECT id, task_no, warehouse_id, status, current_cart_id, source
|
||
FROM wms_wave_pick_task
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
${restrictCreatorId !== null ? 'AND pick_user_id = :restrictCreatorId' : ''}
|
||
LIMIT 1
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
...(restrictCreatorId !== null ? { restrictCreatorId } : {}),
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
const taskRow = Array.isArray(taskRows) ? taskRows[0] : null;
|
||
if (!taskRow) {
|
||
if (restrictCreatorId !== null) {
|
||
const taskRowsWithoutCreator = await this.ctx.model.query(`
|
||
SELECT id
|
||
FROM wms_wave_pick_task
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
if (Array.isArray(taskRowsWithoutCreator) && taskRowsWithoutCreator.length > 0) {
|
||
const error = new Error('仅允许取消本人创建的任务');
|
||
error.statusCode = 403;
|
||
error.data = {
|
||
task_id: taskId,
|
||
warehouse_id: warehouseId,
|
||
operator_id: restrictCreatorId,
|
||
};
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
const error = new Error('任务不存在');
|
||
error.statusCode = 404;
|
||
error.data = {
|
||
task_id: taskId,
|
||
warehouse_id: warehouseId,
|
||
};
|
||
throw error;
|
||
}
|
||
|
||
const taskStatus = Number(taskRow.status || 0);
|
||
// status 2(待复核)、3(已完成)不允许取消,此时库存已扣减且订单已标记拣货完成
|
||
if (![ 0, 1 ].includes(taskStatus)) {
|
||
const statusMessages = { 2: '待复核', 3: '已完成', 9: '已取消' };
|
||
const statusText = statusMessages[taskStatus] || `状态${taskStatus}`;
|
||
const error = new Error(`当前任务已${statusText},不允许取消`);
|
||
error.statusCode = 400;
|
||
error.data = {
|
||
task_id: taskId,
|
||
task_no: String(taskRow.task_no || '').trim(),
|
||
warehouse_id: warehouseId,
|
||
status: taskStatus,
|
||
};
|
||
throw error;
|
||
}
|
||
|
||
const taskSource = Number(taskRow.source || 0);
|
||
const taskNo = String(taskRow.task_no || '').trim();
|
||
|
||
const taskWaveRows = await this.ctx.model.query(`
|
||
SELECT wave_id
|
||
FROM wms_wave_pick_task_wave
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
const waveIds = [ ...new Set((Array.isArray(taskWaveRows) ? taskWaveRows : [])
|
||
.map(row => Number(row && row.wave_id || 0))
|
||
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
|
||
|
||
const taskOrderRows = await this.ctx.model.query(`
|
||
SELECT order_id
|
||
FROM wms_wave_pick_task_order
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
const taskOrderIds = [ ...new Set((Array.isArray(taskOrderRows) ? taskOrderRows : [])
|
||
.map(row => Number(row && row.order_id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
|
||
|
||
// 收集订单操作日志(提交后统一写入)
|
||
for (const orderId of taskOrderIds) {
|
||
cancelOrderLogItems.push({
|
||
orderId,
|
||
operationCode: 'ORDER_WAVE_CANCEL',
|
||
message: `取消拣货任务 ${taskNo},从波次释放`,
|
||
});
|
||
}
|
||
|
||
// source=2(后台/扫描创建)不释放波次,仅清理任务-波次关联
|
||
const isScanCreated = taskSource === 2;
|
||
let releasedWaveRows = [];
|
||
if (waveIds.length > 0) {
|
||
if (!isScanCreated) {
|
||
// PDA 抓取:释放波次
|
||
releasedWaveRows = await this.ctx.model.query(`
|
||
SELECT wave_id, wave_no
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
FOR UPDATE
|
||
`, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveIds,
|
||
},
|
||
type: this.ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
});
|
||
|
||
await orderModel.update({
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
wave_strategy_version: 0,
|
||
wave_scan_result: 0,
|
||
}, {
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
wave_id: { [Op.in]: waveIds },
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
await this.ctx.model.query(`
|
||
DELETE FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id IN (:waveIds)
|
||
`, {
|
||
replacements: {
|
||
warehouseId,
|
||
waveIds,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
// 清理波次订单索引
|
||
await this.deleteOrderWaveIndexByWaveIds({
|
||
warehouseId,
|
||
waveIds,
|
||
transaction,
|
||
});
|
||
|
||
if (Array.isArray(releasedWaveRows) && releasedWaveRows.length > 0) {
|
||
hasReleasedWaves = true;
|
||
}
|
||
}
|
||
|
||
// 清理任务-波次关联(所有来源都需要)
|
||
await this.ctx.model.query(`
|
||
DELETE FROM wms_wave_pick_task_wave
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
// 当任务状态为待复核(2)或已完成(3)时,回退订单拣货状态(仅 PDA 抓取)
|
||
if (!isScanCreated && [ 2, 3 ].includes(taskStatus)) {
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_pick_task_order
|
||
SET pick_status = 0,
|
||
picked_time = NULL,
|
||
update_time = NOW()
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
AND pick_status = 1
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
const pickedOrderIds = [ ...new Set((Array.isArray(taskOrderRows) ? taskOrderRows : [])
|
||
.map(row => Number(row && row.order_id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
|
||
|
||
if (pickedOrderIds.length > 0) {
|
||
await orderModel.update({
|
||
pick_status: 'padding',
|
||
}, {
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
id: {
|
||
[Op.in]: pickedOrderIds,
|
||
},
|
||
pick_status: 'fin',
|
||
},
|
||
transaction,
|
||
validate: false,
|
||
hooks: false,
|
||
});
|
||
}
|
||
}
|
||
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_wave_pick_task
|
||
SET
|
||
status = 9,
|
||
wave_count = 0,
|
||
${hasCancelledAtColumn ? 'cancelled_at = NOW(),' : ''}
|
||
update_time = NOW()
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
await this.ctx.model.query(`
|
||
UPDATE wms_pick_task_cart_binding
|
||
SET
|
||
is_active = 0,
|
||
unbind_user_id = :operatorId,
|
||
unbind_time = NOW(),
|
||
update_time = NOW()
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
AND is_active = 1
|
||
`, {
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
operatorId,
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
await this.bulkInsertRows('wms_wave_pick_action_log', [{
|
||
task_id: taskId,
|
||
warehouse_id: warehouseId,
|
||
wave_id: Array.isArray(releasedWaveRows) && releasedWaveRows.length > 0
|
||
? Number(releasedWaveRows[0].wave_id || 0)
|
||
: 0,
|
||
order_id: taskOrderIds.length > 0 ? Number(taskOrderIds[0]) : null,
|
||
sku_id: null,
|
||
location_id: null,
|
||
box_no: null,
|
||
cart_id: Number(taskRow.current_cart_id || 0) > 0 ? Number(taskRow.current_cart_id) : null,
|
||
qty_delta: 0,
|
||
action_type: 'cancel',
|
||
request_id: requestId,
|
||
operator_id: Number.isInteger(operatorId) ? operatorId : 0,
|
||
device_id: null,
|
||
seq_no: 1,
|
||
snapshot: JSON.stringify({
|
||
task_no: taskNo,
|
||
source: taskSource,
|
||
released_wave_ids: isScanCreated ? [] : waveIds,
|
||
released_order_count: isScanCreated ? 0 : taskOrderIds.length,
|
||
}),
|
||
}], transaction);
|
||
|
||
await this.bulkInsertRows('wms_order_pick_trace', [{
|
||
warehouse_id: warehouseId,
|
||
order_id: taskOrderIds.length > 0 ? Number(taskOrderIds[0]) : 0,
|
||
task_id: taskId,
|
||
cart_id: Number(taskRow.current_cart_id || 0) > 0 ? Number(taskRow.current_cart_id) : null,
|
||
cart_code_snapshot: null,
|
||
pick_user_id: null,
|
||
pick_time: null,
|
||
review_user_id: null,
|
||
review_time: null,
|
||
review_result: null,
|
||
event_type: 'task_cancelled',
|
||
event_desc: isScanCreated
|
||
? `任务取消(未释放波次): ${taskNo || taskId}`
|
||
: `任务取消并释放波次: ${taskNo || taskId}`,
|
||
operator_id: Number.isInteger(operatorId) ? operatorId : 0,
|
||
operator_name: operatorName,
|
||
snapshot: JSON.stringify({
|
||
task_no: taskNo,
|
||
source: taskSource,
|
||
released_wave_ids: isScanCreated ? [] : waveIds,
|
||
released_order_count: isScanCreated ? 0 : taskOrderIds.length,
|
||
released_wave_nos: isScanCreated
|
||
? []
|
||
: (Array.isArray(releasedWaveRows) ? releasedWaveRows : [])
|
||
.map(row => String(row && row.wave_no || '').trim())
|
||
.filter(Boolean),
|
||
}),
|
||
}], transaction);
|
||
|
||
cancelledTaskNos.push(taskNo);
|
||
}
|
||
|
||
await transaction.commit();
|
||
|
||
if (cancelOrderLogItems.length > 0) {
|
||
await this.batchCreateOrderOperationLogs(cancelOrderLogItems, {
|
||
warehouseId,
|
||
scene: 'cancelWavePickTasksInternal',
|
||
});
|
||
}
|
||
|
||
if (hasReleasedWaves) {
|
||
setImmediate(() => {
|
||
this.submitWaveStrategyQuickScanForWarehouse(warehouseId).catch(err => {
|
||
this.ctx.logger.warn('[wave.wavePickTaskCancel] 触发回池后重扫失败', {
|
||
warehouseId,
|
||
error: err && err.message ? err.message : String(err),
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
return {
|
||
cancelled_count: normalizedTaskIds.length,
|
||
task_ids: normalizedTaskIds,
|
||
task_nos: cancelledTaskNos,
|
||
};
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 取消拣货任务并释放关联波次。
|
||
*
|
||
* 仅允许取消状态为 0/1/2/3 的任务。取消后会回收拣货车绑定、
|
||
* 删除任务关联波次并将订单 wave_id 清空,使订单可重新参与后续策略抓取。
|
||
* 当任务状态为 2(待复核)或 3(已完成)时,还会回退已拣货订单的拣货状态。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {Array<number|string>} data.task_ids 任务ID数组。
|
||
* @return {Promise<Object>} 取消结果。
|
||
*/
|
||
async wavePickTaskCancel(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
const sourceTaskIds = Array.isArray(normalizedData.task_ids) ? normalizedData.task_ids : [];
|
||
if (sourceTaskIds.length === 0) {
|
||
return this.fail('task_ids 必须为非空数组', {}, 400);
|
||
}
|
||
|
||
const normalizedTaskIds = [];
|
||
for (const item of sourceTaskIds) {
|
||
const taskId = Number(item);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return this.fail('task_ids 必须为正整数数组', {
|
||
data: {
|
||
task_ids: sourceTaskIds,
|
||
},
|
||
}, 400);
|
||
}
|
||
normalizedTaskIds.push(taskId);
|
||
}
|
||
const taskIds = [ ...new Set(normalizedTaskIds) ];
|
||
if (taskIds.length === 0) {
|
||
return this.fail('task_ids 必须为非空数组', {}, 400);
|
||
}
|
||
|
||
const resolvedWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(resolvedWarehouseId) || resolvedWarehouseId <= 0) {
|
||
return this.fail('未获取到仓库上下文', {}, 400);
|
||
}
|
||
|
||
const operatorInfo = this.getOrderLogOperator();
|
||
const operatorId = Number(operatorInfo.id || 0);
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 400);
|
||
}
|
||
const operatorName = String(operatorInfo.name || 'system').trim() || 'system';
|
||
|
||
try {
|
||
const result = await this.cancelWavePickTasksInternal({
|
||
taskIds,
|
||
warehouseId: resolvedWarehouseId,
|
||
operatorId,
|
||
operatorName,
|
||
restrictCreatorId: null,
|
||
});
|
||
|
||
return this.success('ok', result);
|
||
} catch (error) {
|
||
if (Number.isInteger(error.statusCode) && error.statusCode >= 400 && error.statusCode < 500) {
|
||
return this.fail(error.message, {
|
||
data: this.isPlainObject(error.data) ? error.data : {},
|
||
}, error.statusCode);
|
||
}
|
||
|
||
return this.fail(`取消拣货任务失败: ${error.message}`, {
|
||
data: {
|
||
task_ids: taskIds,
|
||
warehouse_id: resolvedWarehouseId,
|
||
},
|
||
}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 取消本人创建的单个拣货任务并释放关联波次。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {number|string} data.task_id 任务ID。
|
||
* @return {Promise<Object>} 取消结果。
|
||
*/
|
||
async wavePickTaskCancelSelf(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
if (Object.prototype.hasOwnProperty.call(normalizedData, 'task_ids')) {
|
||
return this.fail('当前接口仅支持单个 task_id,请勿传 task_ids', {
|
||
data: {
|
||
task_ids: normalizedData.task_ids,
|
||
},
|
||
}, 400);
|
||
}
|
||
|
||
const taskId = Number(normalizedData.task_id);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return this.fail('task_id 必须为正整数', {
|
||
data: {
|
||
task_id: normalizedData.task_id,
|
||
},
|
||
}, 400);
|
||
}
|
||
|
||
const resolvedWarehouseId = Number(this.getWarehouseId() || 0);
|
||
if (!Number.isInteger(resolvedWarehouseId) || resolvedWarehouseId <= 0) {
|
||
return this.fail('未获取到仓库上下文', {}, 400);
|
||
}
|
||
|
||
const operatorInfo = this.getOrderLogOperator();
|
||
const operatorId = Number(operatorInfo.id || 0);
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 400);
|
||
}
|
||
const operatorName = String(operatorInfo.name || 'system').trim() || 'system';
|
||
|
||
try {
|
||
const result = await this.cancelWavePickTasksInternal({
|
||
taskIds: [ taskId ],
|
||
warehouseId: resolvedWarehouseId,
|
||
operatorId,
|
||
operatorName,
|
||
restrictCreatorId: operatorId,
|
||
});
|
||
|
||
return this.success('ok', result);
|
||
} catch (error) {
|
||
if (Number.isInteger(error.statusCode) && error.statusCode >= 400 && error.statusCode < 500) {
|
||
return this.fail(error.message, {
|
||
data: this.isPlainObject(error.data) ? error.data : {},
|
||
}, error.statusCode);
|
||
}
|
||
|
||
return this.fail(`取消本人拣货任务失败: ${error.message}`, {
|
||
data: {
|
||
task_id: taskId,
|
||
warehouse_id: resolvedWarehouseId,
|
||
},
|
||
}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 后台按策略直接抓取并创建波次。
|
||
*
|
||
* @param {Object} [data={}] 请求参数。
|
||
* @param {number|string} data.strategy_id 波次策略ID(支持 strategyId)。
|
||
* @return {Promise<Object>} 建波结果。
|
||
*/
|
||
async waveStrategyFetchAdmin(data = {}) {
|
||
const normalizedData = this.isPlainObject(data) ? data : {};
|
||
const strategyId = this.normalizeRequiredPositiveInteger(
|
||
normalizedData.strategy_id ?? normalizedData.strategyId,
|
||
'strategy_id'
|
||
);
|
||
|
||
let warehouseId;
|
||
try {
|
||
warehouseId = Number(this.getWarehouseId());
|
||
} catch (error) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw new Error('未识别到当前仓库上下文');
|
||
}
|
||
|
||
const operatorInfo = this.getOrderLogOperator();
|
||
const plan = await this.prepareWaveStrategyFetchPlan({
|
||
strategyId,
|
||
warehouseId,
|
||
operator: {
|
||
operator_id: operatorInfo.id,
|
||
operator_name: operatorInfo.name,
|
||
},
|
||
source: 'admin',
|
||
data: normalizedData,
|
||
});
|
||
|
||
if (Array.isArray(plan.validation_errors) && plan.validation_errors.length > 0) {
|
||
return this.fail('按策略抓取预处理校验失败', {
|
||
data: {
|
||
status: 'failed',
|
||
fetch_state: 2,
|
||
tip: '建波失败,请重试',
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'admin',
|
||
plan,
|
||
},
|
||
}, 400);
|
||
}
|
||
|
||
try {
|
||
const directFetchResult = await this.executeWaveStrategyDirectFetch({
|
||
plan,
|
||
waveBatchSource: 0,
|
||
});
|
||
|
||
this.ctx.logger.info('[wave.waveStrategyFetchAdmin] 建波成功', {
|
||
warehouseId,
|
||
strategyId,
|
||
strategyType: directFetchResult.strategy_type,
|
||
createdWaveCount: directFetchResult.created_wave_count,
|
||
createdOrderCount: directFetchResult.created_order_count,
|
||
});
|
||
|
||
return this.success('ok', {
|
||
status: 'success',
|
||
fetch_state: 1,
|
||
tip: '建波成功',
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'admin',
|
||
plan,
|
||
wave_ids: directFetchResult.wave_ids,
|
||
wave_nos: directFetchResult.wave_nos,
|
||
order_ids: directFetchResult.order_ids,
|
||
created_wave_count: directFetchResult.created_wave_count,
|
||
created_order_count: directFetchResult.created_order_count,
|
||
wave_prefix: directFetchResult.wave_prefix,
|
||
wave_prefix_source: directFetchResult.wave_prefix_source,
|
||
candidate_count: directFetchResult.candidate_count,
|
||
grouped_count: directFetchResult.grouped_count,
|
||
strategy_type: directFetchResult.strategy_type,
|
||
accepted_at: new Date().toISOString(),
|
||
});
|
||
} catch (error) {
|
||
return this.fail(`按策略抓取建波失败: ${error.message}`, {
|
||
data: {
|
||
status: 'failed',
|
||
fetch_state: 2,
|
||
tip: '建波失败,请重试',
|
||
warehouse_id: warehouseId,
|
||
strategy_id: strategyId,
|
||
source: 'admin',
|
||
plan,
|
||
},
|
||
}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 删除指定订单的波次索引记录。
|
||
*
|
||
* @param {Object} [params={}] 参数对象。
|
||
* @param {number|string} [params.warehouseId] 仓库ID。
|
||
* @param {Array<number|string>} [params.orderIds] 订单ID列表。
|
||
* @param {Object} [params.transaction] 事务对象。
|
||
* @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,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 删除指定波次的波次索引记录。
|
||
*
|
||
* @param {Object} [params={}] 参数对象。
|
||
* @param {number|string} [params.warehouseId] 仓库ID。
|
||
* @param {Array<number|string>} [params.waveIds] 波次ID列表。
|
||
* @param {Object} [params.transaction] 事务对象。
|
||
* @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>} [params.orderIds] 订单ID列表。
|
||
* @param {Object} [params.orderModel] 订单模型实例。
|
||
* @param {Object} [params.transaction] 事务对象。
|
||
* @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,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 按波次ID批量替换订单波次索引记录。
|
||
*
|
||
* @param {Object} [params={}] 参数对象。
|
||
* @param {number|string} [params.warehouseId] 仓库ID。
|
||
* @param {Array<number|string>} [params.waveIds] 波次ID列表。
|
||
* @param {Object} [params.orderModel] 订单模型实例。
|
||
* @param {Object} [params.transaction] 事务对象。
|
||
* @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', 'sys_logistics_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 || ''),
|
||
sys_logistics_code: String(row && row.sys_logistics_code || ''),
|
||
});
|
||
}
|
||
|
||
await this.deleteOrderWaveIndexByWaveIds({
|
||
warehouseId: normalizedWarehouseId,
|
||
waveIds: normalizedWaveIds,
|
||
transaction,
|
||
});
|
||
|
||
const allOrderIds = [ ...new Set(orderRowsList
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
if (allOrderIds.length > 0) {
|
||
await this.deleteOrderWaveIndexByOrderIds({
|
||
warehouseId: normalizedWarehouseId,
|
||
orderIds: allOrderIds,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
const valueSqlList = [];
|
||
const replacements = {
|
||
warehouseId: normalizedWarehouseId,
|
||
};
|
||
|
||
let rowIndex = 0;
|
||
for (const waveId of normalizedWaveIds) {
|
||
const rawOrderRows = waveOrderRowsMap.get(waveId) || [];
|
||
// 按平台+快递排序:同平台、同快递订单聚合在一起,确保 wave_index 连续分配
|
||
const orderRowsByWave = [ ...rawOrderRows ].sort((a, b) => {
|
||
const platformA = String(
|
||
(a && a.sys_platform_code) || (a && a.source_platform_code) || ''
|
||
).trim().toLowerCase();
|
||
const platformB = String(
|
||
(b && b.sys_platform_code) || (b && b.source_platform_code) || ''
|
||
).trim().toLowerCase();
|
||
if (platformA !== platformB) return platformA.localeCompare(platformB);
|
||
const logisticsA = String((a && a.sys_logistics_code) || '').trim().toLowerCase();
|
||
const logisticsB = String((b && b.sys_logistics_code) || '').trim().toLowerCase();
|
||
if (logisticsA !== logisticsB) return logisticsA.localeCompare(logisticsB);
|
||
return (Number(a && a.id) || 0) - (Number(b && b.id) || 0);
|
||
});
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* 兼容旧方法名 fetch,内部转调 groupFetch。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @return {Promise<Object>} 任务提交结果。
|
||
*/
|
||
async fetch(data = {}) {
|
||
return this.groupFetch(data);
|
||
}
|
||
|
||
}
|
||
|
||
module.exports = WaveService;
|