WMS_MAIN/app/service/systems/wave_batch_closure.js
liufumingren 90d5701a53 feat(wave): item_detail_machine 改 TEXT 并新增波次自动终结
- wms_wave_batch.item_detail_machine VARCHAR(1024) -> TEXT, 兼容多商品长结构标识
- 新增 wave_batch_closure 服务: 扫描活动波次(0/1)中订单已全部离开待处理表的波次并收敛 wave_status=5
- 新增 sync_finished_wave_batch 定时任务与执行日志缓存
2026-08-21 02:20:17 +08:00

174 lines
6.2 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// app/service/systems/wave_batch_closure.js
'use strict';
const MainService = require('../main');
// 活动中的波次状态(batchList 可见口径)
const ACTIVE_WAVE_STATUSES = [ 0, 1 ];
// 终结态:复核完成(与 recheckOrder 复核完成路径一致,使波次从 batchList 中自然消失)
const CLOSED_WAVE_STATUS = 5;
// 创建不足该分钟数的波次不参与自动终结,避免与创建事务并发误判
const WAVE_MIN_AGE_MINUTES = 5;
// 单次 SQL IN 列表的波次数量上限
const WAVE_ID_BATCH_SIZE = 500;
/**
* 波次批次自动终结服务。
*
* 背景:波次内订单全部离开待处理表后(发货迁移配送表、库内拦截确认、取消等),
* 若相关路径未回写 wms_wave_batch,波次会停留在 wave_status IN (0,1),
* 导致 order.wave.batchList 展示 0 单波次。
*
* 本服务按仓库扫描活动波次,对"待处理表中已无任何订单"的波次,
* 将 wave_status 收敛为 5(复核完成),使其从批次列表中消失。
*/
class WaveBatchClosureService extends MainService {
/**
* 扫描并关闭"订单已全部离表"的活动波次。
*
* @param {Object} [options={}] 执行选项。
* @param {boolean} [options.dryRun=false] 仅盘点不更新(用于验证命中范围)。
* @return {Promise<Object>} 执行结果汇总。
*/
async closeFinishedWaves(options = {}) {
const { ctx } = this;
const startedAt = Date.now();
const dryRun = Boolean(options && options.dryRun);
const candidateRows = await ctx.model.query(
`SELECT wave_id, wave_no, warehouse_id, wave_status, total_orders
FROM wms_wave_batch
WHERE wave_status IN (:waveStatuses)
AND total_orders > 0
AND create_time < (NOW() - INTERVAL ${WAVE_MIN_AGE_MINUTES} MINUTE)`,
{
replacements: { waveStatuses: ACTIVE_WAVE_STATUSES },
type: ctx.model.QueryTypes.SELECT,
}
);
// 按仓库分组,过滤非法数据
const warehouseWaveMap = new Map();
for (const row of (Array.isArray(candidateRows) ? candidateRows : [])) {
const warehouseId = Number(row && row.warehouse_id || 0);
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(warehouseId) || warehouseId <= 0
|| !Number.isInteger(waveId) || waveId <= 0) {
continue;
}
if (!warehouseWaveMap.has(warehouseId)) {
warehouseWaveMap.set(warehouseId, []);
}
warehouseWaveMap.get(warehouseId).push({
waveId,
waveNo: String(row && row.wave_no || '').trim(),
warehouseId,
});
}
const warehouseIds = Array.from(warehouseWaveMap.keys());
const closedWaves = [];
for (const warehouseId of warehouseIds) {
const waves = warehouseWaveMap.get(warehouseId);
let currentTableName = '';
try {
const factory = ctx.model && ctx.model.OrderDeliveryFactory;
if (!factory || typeof factory.generateTableName !== 'function') {
throw new Error('订单工厂不可用');
}
currentTableName = factory.generateTableName(warehouseId, 'current');
} catch (error) {
ctx.logger.warn(`[wave-batch-closure] 生成仓库 ${warehouseId} 订单表名失败,跳过: ${error.message}`);
continue;
}
// 分批查询待处理表中仍存在订单的波次
const existingWaveIds = new Set();
let warehouseQueryFailed = false;
for (let offset = 0; offset < waves.length; offset += WAVE_ID_BATCH_SIZE) {
const batchWaves = waves.slice(offset, offset + WAVE_ID_BATCH_SIZE);
const batchWaveIds = batchWaves.map(item => item.waveId);
try {
const existingRows = await ctx.model.query(
`SELECT DISTINCT wave_id
FROM ${currentTableName}
WHERE wave_id IN (:waveIds)`,
{
replacements: { waveIds: batchWaveIds },
type: ctx.model.QueryTypes.SELECT,
}
);
for (const row of (Array.isArray(existingRows) ? existingRows : [])) {
const waveId = Number(row && row.wave_id || 0);
if (Number.isInteger(waveId) && waveId > 0) {
existingWaveIds.add(waveId);
}
}
} catch (error) {
warehouseQueryFailed = true;
ctx.logger.warn(`[wave-batch-closure] 查询仓库 ${warehouseId} 待处理表失败,跳过该仓库: ${error.message}`);
break;
}
}
if (warehouseQueryFailed) {
continue;
}
const finishedWaves = waves.filter(item => !existingWaveIds.has(item.waveId));
if (finishedWaves.length > 0) {
closedWaves.push(...finishedWaves);
}
}
const closedWaveIds = closedWaves.map(item => item.waveId);
const candidateCount = Array.from(warehouseWaveMap.values()).reduce((sum, waves) => sum + waves.length, 0);
if (!dryRun && closedWaveIds.length > 0) {
for (let offset = 0; offset < closedWaveIds.length; offset += WAVE_ID_BATCH_SIZE) {
const batchWaveIds = closedWaveIds.slice(offset, offset + WAVE_ID_BATCH_SIZE);
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = :closedStatus,
processed_orders = total_orders,
check_time = NOW(),
update_time = NOW()
WHERE wave_id IN (:waveIds)
AND wave_status IN (:waveStatuses)
AND total_orders > 0`,
{
replacements: {
closedStatus: CLOSED_WAVE_STATUS,
waveIds: batchWaveIds,
waveStatuses: ACTIVE_WAVE_STATUSES,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
}
}
const result = {
dryRun,
candidate_count: candidateCount,
closed_count: closedWaves.length,
warehouse_ids: warehouseIds,
closed_waves: closedWaves,
duration_ms: Date.now() - startedAt,
};
if (closedWaves.length > 0) {
ctx.logger.info(
`[wave-batch-closure] 波次终结结果 dryRun=${dryRun} closed=${closedWaves.length}/${candidateCount} waves=${closedWaveIds.join(',')}`
);
}
return result;
}
}
module.exports = WaveBatchClosureService;