fix(wave): 波次订单移出/取消后 wms_order_wave_index 未重新排序

- batchRemoveOrders: 用 replaceOrderWaveIndexByWaveIds 替换手动 COUNT,移出后自动重排 wave_index
- cancelWavePickTasksInternal: PDA拣货任务取消释放波次时清理 wms_order_wave_index
- batchFinishAutoGrouping: 关闭自动加团前重建波次索引,确保 wave_index 连续
- cancelOrder(pendingOrder): 取消待处理订单后重建受影响波次索引
- cloneOrder: 克隆取消原订单时清理波次关联并重建索引
- Qimen取消: 奇门取消订单后重建波次索引
- OpenAPI取消: 新增完整波次清理逻辑(清除wave_id+删索引+重建+更新WaveBatch)
- 新增 resortWaveIndex 内部方法用于强制重排历史数据
This commit is contained in:
liufumingren 2026-08-02 00:35:56 +08:00
parent 05b71b2f31
commit d6e4de6edc
5 changed files with 310 additions and 50 deletions

View File

@ -65,15 +65,65 @@ class OpenapiOrderService extends MainService {
return this.fail('取消失败,已通知拦截执行');
}
await existingOrder.update({
// 检查是否在波次中,若在波次中需清除波次关联
const existingWaveId = Number(existingOrder.wave_id || 0);
const updateValues = {
status: 'cancel',
outbound_status: 'fin',
step: 4,
updated_at: new Date(),
}, {
};
if (existingWaveId > 0) {
updateValues.wave_id = 0;
updateValues.wave_no = '';
}
await existingOrder.update(updateValues, {
transaction,
});
// 波次清理:删除波次索引、重建波次索引、更新波次统计
if (existingWaveId > 0) {
try {
await ctx.service.systemMethods.order.wave.deleteOrderWaveIndexByOrderIds({
warehouseId,
orderIds: [ existingOrder.id ],
transaction,
});
await ctx.service.systemMethods.order.wave.replaceOrderWaveIndexByWaveIds({
warehouseId,
waveIds: [ existingWaveId ],
orderModel: DeliveryModel,
transaction,
});
const WaveBatch = ctx.model.WaveBatch;
if (WaveBatch) {
const wave = await WaveBatch.findOne({
where: { wave_id: existingWaveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'total_orders', 'wave_status' ],
raw: true,
transaction,
});
if (wave) {
const totalOrders = Number(wave.total_orders);
const normalizedTotalOrders = Number.isFinite(totalOrders) ? totalOrders : 0;
if (normalizedTotalOrders <= 0) {
await WaveBatch.update(
{ total_orders: 0, wave_status: -1, update_time: new Date() },
{ where: { wave_id: existingWaveId, warehouse_id: warehouseId }, transaction }
);
}
}
}
} catch (waveErr) {
ctx.logger.warn('[OpenapiOrderCancel] 清理波次关联失败,不影响订单取消', waveErr);
}
}
// 释放储位分配锁定库存
await this.releaseStockLockForCancel({
orderId: existingOrder.id,

View File

@ -243,7 +243,15 @@ class orderServer extends MainService {
try {
await ctx.service.systemMethods.order.wave.deleteOrderWaveIndexByOrderIds({
warehouseId: info.warehouseId,
orderIds: [existingOrder.id],
orderIds: [ existingOrder.id ],
transaction,
});
// 重建受影响波次的订单索引(wave_index 重新排序)
await ctx.service.systemMethods.order.wave.replaceOrderWaveIndexByWaveIds({
warehouseId: info.warehouseId,
waveIds: [ existingWaveId ],
orderModel: DeliveryModel,
transaction,
});
@ -262,7 +270,7 @@ class orderServer extends MainService {
const wave = await WaveBatch.findOne({
where: { wave_id: existingWaveId, warehouse_id: info.warehouseId },
attributes: ['wave_id', 'total_orders', 'wave_status'],
attributes: [ 'wave_id', 'total_orders', 'wave_status' ],
raw: true,
transaction,
});
@ -297,7 +305,7 @@ class orderServer extends MainService {
try {
ctx.service.systemMethods.order.wave.enqueueWaveStrategyQuickScanPostOrderChange(
info.warehouseId,
[existingOrder.id],
[ existingOrder.id ],
{ triggerScan: true, source: 'qimenCancel' }
);
} catch (scanErr) {

View File

@ -1992,13 +1992,22 @@ class PendingOrderService extends OrderBaseService {
* 批量分配待处理订单的快递号,并复用现有运单创建核心链路。
*
* @param {Object} data 请求体。
* @param {Array<Object>} data.orders 订单对象数组。
* @param {Array<number>} data.ids 订单 ID 数组(推荐)。
* @param {Array<Object>} [data.orders] 订单对象数组(兼容旧格式,新调用方请使用 ids)。
* @return {Promise<Object>} 统一 success 包装,立即返回 task_id。
*/
async allocateExpressCode(data) {
const { orders } = data || {};
if (!Array.isArray(orders)) {
throw new Error('分配快递号接口仅支持订单对象数组入参');
const { ids, orders: legacyOrders } = data || {};
// 新格式:ids,直接转为管线所需格式(business_key 固定为 1)
let orders;
if (Array.isArray(ids) && ids.length > 0) {
orders = ids.map(id => ({ order_id: Number(id), business_key: 1 }));
} else if (Array.isArray(legacyOrders)) {
// 兼容旧格式:orders 对象数组
orders = legacyOrders;
} else {
throw new Error('分配快递号接口需要传入 ids(订单ID数组)或 orders(订单对象数组)');
}
const { service } = this;
@ -2345,6 +2354,18 @@ class PendingOrderService extends OrderBaseService {
orderIds: waveOrderIds,
transaction: undefined,
});
// 重建受影响波次的订单索引(wave_index 重新排序)
const affectedWaveIds = [ ...new Set(ordersWithWave
.map(order => Number(order.wave_id))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
if (affectedWaveIds.length > 0) {
await this.ctx.service.systemMethods.order.wave.replaceOrderWaveIndexByWaveIds({
warehouseId,
waveIds: affectedWaveIds,
orderModel: model,
});
}
}
if (WaveBatch) {
@ -3014,14 +3035,37 @@ class PendingOrderService extends OrderBaseService {
}
const now = new Date();
const originalWaveId = Number(original.wave_id || 0);
// 3. 取消原订单
await model.update({
// 3. 取消原订单(若在波次中需清除波次关联)
const cancelUpdateValues = {
status: 'cancel',
step: 9,
outbound_status: 'padding',
updated_at: now,
}, { where });
};
if (originalWaveId > 0) {
cancelUpdateValues.wave_id = 0;
cancelUpdateValues.wave_no = '';
}
await model.update(cancelUpdateValues, { where });
// 克隆时清理波次索引(不影响主流程)
if (originalWaveId > 0) {
try {
await this.ctx.service.systemMethods.order.wave.deleteOrderWaveIndexByOrderIds({
warehouseId,
orderIds: [ orderId ],
});
await this.ctx.service.systemMethods.order.wave.replaceOrderWaveIndexByWaveIds({
warehouseId,
waveIds: [ originalWaveId ],
orderModel: model,
});
} catch (waveErr) {
this.ctx.logger.warn('[PendingOrderService.cloneOrder] 清理波次关联失败,不影响克隆', waveErr);
}
}
// 记录原订单"克隆"日志
try {

View File

@ -3012,7 +3012,7 @@ class WaveService extends OrderBaseService {
AND o.lock_status = 'none'
INNER JOIN (
SELECT
COALESCE(NULLIF(TRIM(COALESCE(src.items_hash, '')), ''), TRIM(COALESCE(src.items, ''))) AS structure_key,
src.items_hash AS structure_key,
COUNT(1) AS same_structure_count
FROM ${orderTableName} src
WHERE src.warehouse_id = :warehouseId
@ -3025,9 +3025,9 @@ class WaveService extends OrderBaseService {
AND src.outbound_status != 'padding'
AND src.intercept_status = 'none'
AND src.lock_status = 'none'
GROUP BY COALESCE(NULLIF(TRIM(COALESCE(src.items_hash, '')), ''), TRIM(COALESCE(src.items, '')))
GROUP BY src.items_hash
) same_structure
ON same_structure.structure_key = COALESCE(NULLIF(TRIM(COALESCE(o.items_hash, '')), ''), TRIM(COALESCE(o.items, '')))
ON same_structure.structure_key = o.items_hash
INNER JOIN wms_wave_strategy s
ON s.id = m.strategy_id
AND s.warehouse_id = :warehouseId
@ -7061,39 +7061,14 @@ class WaveService extends OrderBaseService {
const updatedOrderCount = Number(Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0);
await this.deleteOrderWaveIndexByOrderIds({
// 重建受影响波次的订单索引(wave_index 重新排序),并获取各波次剩余订单数量
const remainingCountMap = await this.replaceOrderWaveIndexByWaveIds({
warehouseId,
orderIds: removedOrderIds,
waveIds: affectedWaveIds,
orderModel,
transaction,
});
const remainingRows = await orderModel.findAll({
attributes: [
'wave_id',
[ this.ctx.model.fn('COUNT', this.ctx.model.col('id')), 'remaining_count' ],
],
where: {
wave_id: {
[Op.in]: affectedWaveIds,
[Op.gt]: 0,
},
},
group: [ 'wave_id' ],
raw: true,
transaction,
});
const remainingCountMap = new Map();
for (const row of (Array.isArray(remainingRows) ? remainingRows : [])) {
const waveId = Number(row && row.wave_id || 0);
const remainingCount = Number(row && row.remaining_count || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
remainingCountMap.set(waveId, Number.isInteger(remainingCount) && remainingCount > 0 ? remainingCount : 0);
}
const updatedWaveIds = [];
const emptiedWaveIds = [];
@ -7171,6 +7146,173 @@ class WaveService extends OrderBaseService {
}
}
/**
* 强制重排指定波次的订单索引(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;
}
}
/**
* 批量移除异常订单任务提交接口。
*
@ -9203,6 +9345,15 @@ class WaveService extends OrderBaseService {
});
}
// 关闭自动加团前,重建波次订单索引(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,
@ -9969,7 +10120,7 @@ class WaveService extends OrderBaseService {
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderTableName = this.getModelTableSqlName(orderModel);
const structureExpr = alias => `COALESCE(NULLIF(TRIM(COALESCE(${alias}.items_hash, '')), ''), TRIM(COALESCE(${alias}.items, '')))`;
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')}` : '';
@ -12110,6 +12261,13 @@ class WaveService extends OrderBaseService {
transaction,
});
// 清理波次订单索引
await this.deleteOrderWaveIndexByWaveIds({
warehouseId,
waveIds,
transaction,
});
if (Array.isArray(releasedWaveRows) && releasedWaveRows.length > 0) {
hasReleasedWaves = true;
}

View File

@ -3227,7 +3227,7 @@
},
{
"method": "order.pendingOrder.allocateExpressCode",
"description": "批量分配待处理订单的快递号,接收订单对象数组,复用 express.createWaybillCodePipeline。",
"description": "批量分配待处理订单的首单快递号(异步接口)。调用后立即返回 task_id,后台异步执行运单创建;可通过 order.pendingOrder.allocateExpressCodeTaskProgress 查询进度。拆单场景请使用 order.pendingOrder.allocateSubOrderNumber。",
"isNeedAuth": false,
"isNeedLogin": true,
"headers": [
@ -3240,11 +3240,11 @@
],
"params": [
{
"name": "orders",
"type": "array",
"name": "ids",
"type": "array<number>",
"required": true,
"source": "body",
"description": "订单对象数组;每个对象应为待处理订单列表或详情中获取的原始订单对象。每个订单对象必须包含 order_id 与 business_key;sys_platform_code 与 logistics_code 为订单对象自带字段,前端无需额外拼装或从外部构造,直接原样回传订单对象即可。其余字段会原样透传给运单创建链路。business_key 说明:business_key 是运单创建的序号键数组(例如:新分配 1 个运单号时传 [1];订单拆单时可能传 [2,3]),该字段会在 createWaybillCodePipeline 的返回 data 中原样返回,便于前端关联订单与运单创建结果。"
"description": "订单 ID 数组,例如 [123456, 789012]。sys_platform_code、logistics_code 等字段由后端直接从数据库读取,前端无需传参。"
}
],
"response": [
@ -3270,7 +3270,7 @@
"name": "data",
"type": "object",
"required": false,
"description": "createWaybillCodePipeline 返回的运单创建结果,包含 success/failed 列表与 summary 等字段"
"description": "异步受理结果。包含 task_id(任务 ID,用于查询进度)、status(submitted)、message、update_time 等字段。实际运单分配结果需通过 allocateExpressCodeTaskProgress 接口查询。"
}
],
"errors": [