feat(pick): 拣货完成拦截单跳过并移出波次回写统计

- 拦截单不再报错中止, 直接跳过(不完成拣货、不扣减库存)
- source!=0 任务中被跳过的拦截单从波次移除: wave_id 清零、删除波次索引、
  回写 wms_wave_batch.total_orders/processed_orders, 空波次置 wave_status=-1
- 同步清理任务订单关联与箱子明细, 全部跳过时按任务进度完结
This commit is contained in:
liufumingren 2026-08-21 02:20:22 +08:00
parent 90d5701a53
commit 4f2ef5ecb3

View File

@ -1947,7 +1947,9 @@ class PickSystemService extends Service {
}
}
// 检查目标订单是否进入拦截流程,拦截订单不允许完成拣货
// 检查目标订单是否进入拦截流程,拦截订单直接跳过:
// 不完成拣货、不扣减库存(不取出)、不报错,其余订单照常完成
const skippedInterceptedOrders = [];
if (targetOrderIds.length > 0) {
const interceptCheckModel = await this.getOrderModel(warehouseId);
const interceptedOrderRows = await interceptCheckModel.findAll({
@ -1966,16 +1968,290 @@ class PickSystemService extends Service {
});
if (interceptedOrderRows && interceptedOrderRows.length > 0) {
const detailList = interceptedOrderRows.map(
orderRow => `订单${orderRow.id}(intercept_status=${orderRow.intercept_status})`
).join(';');
throw this.createBusinessError(
`以下订单已被拦截,无法完成拣货:${detailList}`,
400
const interceptedOrderIdSet = new Set(
interceptedOrderRows.map(orderRow => Number(orderRow && orderRow.id || 0))
);
for (const orderRow of interceptedOrderRows) {
skippedInterceptedOrders.push({
order_id: Number(orderRow && orderRow.id || 0),
intercept_status: String(orderRow && orderRow.intercept_status || '').trim() || 'none',
});
}
targetOrderIds = targetOrderIds.filter(orderId => !interceptedOrderIdSet.has(orderId));
}
}
// source !== 0(PDA/后台抓取创建的任务)时,被跳过的拦截订单直接从波次中移除:
// 订单 wave_id 清零、重建波次索引、回写波次统计,并移除任务订单关联
const removedFromWaveOrderLogItems = [];
const removedFromWaveOrderIds = [];
if (skippedInterceptedOrders.length > 0 && taskSource !== 0) {
const skippedOrderIds = skippedInterceptedOrders.map(item => item.order_id);
const interceptOrderModel = await this.getOrderModel(warehouseId);
const removableRows = await interceptOrderModel.findAll({
attributes: [ 'id', 'wave_id', 'wave_no' ],
where: {
warehouse_id: warehouseId,
id: {
[this.app.Sequelize.Op.in]: skippedOrderIds,
},
wave_id: {
[this.app.Sequelize.Op.gt]: 0,
},
},
raw: true,
transaction,
});
const normalizedRemovableRows = Array.isArray(removableRows) ? removableRows : [];
const affectedWaveIds = [ ...new Set(normalizedRemovableRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
if (normalizedRemovableRows.length > 0) {
await interceptOrderModel.update({
wave_id: 0,
wave_no: '',
wave_strategy_version: 0,
wave_scan_result: 0,
}, {
where: {
warehouse_id: warehouseId,
id: {
[this.app.Sequelize.Op.in]: normalizedRemovableRows.map(row => Number(row.id)),
},
},
transaction,
});
for (const row of normalizedRemovableRows) {
removedFromWaveOrderIds.push(Number(row && row.id || 0));
removedFromWaveOrderLogItems.push({
orderId: Number(row && row.id || 0),
operationCode: 'ORDER_WAVE_REMOVE',
message: `订单从波次 ${String(row && row.wave_no || '').trim() || '未知波次'} 中移除`,
});
}
if (affectedWaveIds.length > 0) {
const waveService = this.ctx.service
&& this.ctx.service.systemMethods
&& this.ctx.service.systemMethods.order
&& this.ctx.service.systemMethods.order.wave;
// 仅删除拦截单自身的索引行,不重建整波索引:
// 其余订单 wave_index 保持不变(仅跳号),避免与已放货的篮子编号
// (task_order.box_no / task_box.box_no 为创建时 wave_index 快照)错位,
// 保证复核/打印等按 wave_index 排序的环节仍与实物位置一致。
if (waveService && typeof waveService.deleteOrderWaveIndexByOrderIds === 'function') {
await waveService.deleteOrderWaveIndexByOrderIds({
warehouseId,
orderIds: normalizedRemovableRows.map(row => Number(row.id)),
transaction,
});
}
// 按剩余索引行数回写波次统计(删除后未重建,剩余订单序号保持不变)
const remainingIndexRows = await this.ctx.model.query(`
SELECT wave_id, COUNT(*) AS remaining_count
FROM wms_order_wave_index
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
GROUP BY wave_id
`, {
replacements: {
warehouseId,
waveIds: affectedWaveIds,
},
type: this.ctx.model.QueryTypes.SELECT,
transaction,
});
const remainingCountMap = new Map();
for (const row of Array.isArray(remainingIndexRows) ? remainingIndexRows : []) {
const waveId = Number(row && row.wave_id || 0);
const remainingCount = Number(row && row.remaining_count || 0);
if (Number.isInteger(waveId) && waveId > 0) {
remainingCountMap.set(waveId, remainingCount);
}
}
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);
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,
});
}
if (emptiedWaveIds.length > 0) {
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 IN (:waveIds)
`, {
replacements: {
warehouseId,
waveIds: emptiedWaveIds,
},
transaction,
});
}
}
// 移除任务订单关联记录,任务进度不再包含被移出波次的拦截单
await this.ctx.model.query(`
DELETE FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND order_id IN (:orderIds)
`, {
replacements: {
taskId,
warehouseId,
orderIds: normalizedRemovableRows.map(row => Number(row.id)),
},
transaction,
});
// 同步移除拦截单对应的篮子明细(散单模式 box_type=2 绑定订单),避免遗留空盒
const taskBoxColumnSet = await this.getTableColumnSet('wms_wave_pick_task_box');
const taskBoxWarehouseFilterSql = taskBoxColumnSet.has('warehouse_id') ? ' AND warehouse_id = :warehouseId' : '';
await this.ctx.model.query(`
DELETE FROM wms_wave_pick_task_box
WHERE task_id = :taskId
AND order_id IN (:orderIds)
${taskBoxWarehouseFilterSql}
`, {
replacements: {
taskId,
warehouseId,
orderIds: normalizedRemovableRows.map(row => Number(row.id)),
},
transaction,
});
}
}
// 目标订单全部被拦截跳过:不做任何拣货/库存变更,直接成功返回
if (targetOrderIds.length <= 0) {
// mode=1(全部确认)时任务标记完成;mode=2 依据任务进度判断
const skipProgressBeforeComplete = await this.getTaskPickProgress(taskId, warehouseId, transaction);
const skipTaskCompleted = mode === 1 || skipProgressBeforeComplete.isCompleted;
if (skipTaskCompleted) {
await this.ctx.model.query(`
UPDATE wms_wave_pick_task
SET status = 2,
finish_time = NOW(),
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId
`, {
replacements: {
taskId,
warehouseId,
},
transaction,
});
// 同步更新波次关联状态为已拣
const taskWaveColumnSet = await this.getTableColumnSet('wms_wave_pick_task_wave');
const taskWaveWarehouseFilterSql = taskWaveColumnSet.has('warehouse_id') ? ' AND warehouse_id = :warehouseId' : '';
await this.ctx.model.query(`
UPDATE wms_wave_pick_task_wave
SET status = 1,
pick_time = NOW(),
update_time = NOW()
WHERE task_id = :taskId
${taskWaveWarehouseFilterSql}
`, {
replacements: {
taskId,
warehouseId,
},
transaction,
});
} else {
await this.ctx.model.query(`
UPDATE wms_wave_pick_task
SET status = CASE WHEN status = 0 THEN 1 ELSE status END,
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId
`, {
replacements: {
taskId,
warehouseId,
},
transaction,
});
}
await transaction.commit();
const skipProgress = await this.getTaskPickProgress(taskId, warehouseId);
await this._writePickCompleteActionLog({
taskId,
warehouseId,
operatorId,
operatorName,
targetOrderIds: [],
mode,
isCompleted: skipProgress.isCompleted,
progress: skipProgress,
skippedInterceptedOrders,
});
await this._afterSkipInterceptedPostActions({
warehouseId,
operatorId,
operatorName,
removedFromWaveOrderLogItems,
removedFromWaveOrderIds,
});
return {
task_id: taskId,
mode,
confirmed_order_ids: [],
skipped_intercepted_order_ids: skippedInterceptedOrders.map(item => item.order_id),
skipped_intercepted_orders: skippedInterceptedOrders,
removed_from_wave_order_ids: removedFromWaveOrderIds,
is_completed: skipProgress.isCompleted,
task_completed: skipTaskCompleted,
progress: {
total_orders: skipProgress.totalOrders,
picked_orders: skipProgress.pickedOrders,
pending_orders: skipProgress.pendingOrders,
},
};
}
// 检查目标订单是否已分配储位(storage_status='fin'),防止订单在波次中被取消储位分配后仍然完成拣货
if (targetOrderIds.length > 0) {
const orderModel = await this.getOrderModel(warehouseId);
@ -2168,7 +2444,9 @@ class PickSystemService extends Service {
});
const progress = await this.getTaskPickProgress(taskId, warehouseId, transaction);
if (mode === 1 || progress.isCompleted) {
// mode=1(全部确认)时任务直接标记完成;mode=2 依据任务进度判断
const taskCompleted = mode === 1 || progress.isCompleted;
if (taskCompleted) {
await ctx.model.query(`
UPDATE wms_wave_pick_task
SET status = 2,
@ -2231,6 +2509,16 @@ class PickSystemService extends Service {
mode,
isCompleted: progress.isCompleted,
progress,
skippedInterceptedOrders,
});
// 被移出波次的拦截订单:写订单操作日志 + 触发策略快扫(不影响主流程)
await this._afterSkipInterceptedPostActions({
warehouseId,
operatorId,
operatorName,
removedFromWaveOrderLogItems,
removedFromWaveOrderIds,
});
// 写入 order_operation_log 拣货完成日志
@ -2267,7 +2555,11 @@ class PickSystemService extends Service {
task_id: taskId,
mode,
confirmed_order_ids: targetOrderIds,
skipped_intercepted_order_ids: skippedInterceptedOrders.map(item => item.order_id),
skipped_intercepted_orders: skippedInterceptedOrders,
removed_from_wave_order_ids: removedFromWaveOrderIds,
is_completed: progress.isCompleted,
task_completed: taskCompleted,
progress: {
total_orders: progress.totalOrders,
picked_orders: progress.pickedOrders,
@ -2280,6 +2572,81 @@ class PickSystemService extends Service {
}
}
/**
* 拦截单跳过后的收尾动作(均不影响主流程):
* 1. 写入被移出波次拦截订单的 ORDER_WAVE_REMOVE 操作日志;
* 2. 触发波次策略快速扫描,让移出波次的订单重新进入可抓取池。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.operatorId 操作人ID。
* @param {string} params.operatorName 操作人名称。
* @param {Array<Object>} params.removedFromWaveOrderLogItems 波次移除日志项。
* @param {Array<number>} params.removedFromWaveOrderIds 被移出波次的订单ID。
* @return {Promise<void>} 无返回值。
*/
async _afterSkipInterceptedPostActions(params = {}) {
const warehouseId = Number(params && params.warehouseId || 0);
const operatorId = Number(params && params.operatorId || 0);
const operatorName = String(params && params.operatorName || '').trim() || 'system';
const removedFromWaveOrderLogItems = Array.isArray(params && params.removedFromWaveOrderLogItems)
? params.removedFromWaveOrderLogItems
: [];
const removedFromWaveOrderIds = Array.isArray(params && params.removedFromWaveOrderIds)
? params.removedFromWaveOrderIds
: [];
if (removedFromWaveOrderLogItems.length > 0) {
try {
const operationLogService = this.ctx
&& this.ctx.service
&& this.ctx.service.systems
&& this.ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logPayloads = removedFromWaveOrderLogItems.map(item => ({
businessType: 'order',
businessId: `${item.orderId}`,
operationCode: item.operationCode,
operator: {
id: operatorId ? String(operatorId) : null,
name: operatorName,
},
extras: {
message: item.message,
warehouseId,
externalLogType: 'API',
},
}));
await operationLogService.createOperationLogs(logPayloads);
}
} catch (e) {
this.ctx.logger.warn('[pick.wavePickTaskComplete] 写入波次移除操作日志失败,不影响主流程', {
error: e && e.message,
});
}
}
if (removedFromWaveOrderIds.length > 0) {
try {
const waveService = this.ctx.service
&& this.ctx.service.systemMethods
&& this.ctx.service.systemMethods.order
&& this.ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.enqueueWaveStrategyQuickScanPostOrderChange === 'function') {
waveService.enqueueWaveStrategyQuickScanPostOrderChange(
warehouseId,
removedFromWaveOrderIds,
{ triggerScan: true, source: 'pickSkipInterceptedRemoveWave' }
);
}
} catch (e) {
this.ctx.logger.warn('[pick.wavePickTaskComplete] 触发波次策略快扫失败,不影响主流程', {
error: e && e.message,
});
}
}
}
/**
* 写入拣货完成操作日志到 wms_wave_pick_action_log(内部方法)。
*
@ -2292,6 +2659,7 @@ class PickSystemService extends Service {
* @param {number} params.mode 提交模式(1全部确认 2部分确认)。
* @param {boolean} params.isCompleted 任务是否全部完成。
* @param {Object} params.progress 任务进度信息。
* @param {Array<Object>} params.skippedInterceptedOrders 被跳过的拦截订单(order_id + intercept_status)。
* @return {Promise<void>} 无返回值。
*/
async _writePickCompleteActionLog(params = {}) {
@ -2304,6 +2672,7 @@ class PickSystemService extends Service {
mode,
isCompleted,
progress,
skippedInterceptedOrders,
} = params;
const requestId = `pick_complete_${warehouseId}_${taskId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@ -2363,6 +2732,7 @@ class PickSystemService extends Service {
mode,
confirmed_order_ids: targetOrderIds,
confirmed_order_count: Array.isArray(targetOrderIds) ? targetOrderIds.length : 0,
skipped_intercepted_orders: Array.isArray(skippedInterceptedOrders) ? skippedInterceptedOrders : [],
is_completed: isCompleted,
progress: {
total_orders: progress && progress.totalOrders,