feat(order.pendingOrder): 批量锁定跳过已取消订单

取消订单(status=cancel)为终态,被锁定后会残留锁定标记导致无法正常出库。
runBatchLockTask 查询时带出 status,取消订单不参与锁定更新、不写 ORDER_LOCK 日志;
混合批次只锁定未取消订单,并通过 skipped_cancelled_order_count /
skipped_cancelled_order_ids 透出跳过明细。

并发保护:更新语句 where 增加 status != 'cancel',并按实际影响行数回查确认
后才写日志与计数。

同步更新 methods/system.json 与 methods/changes/system.json(0.3.322)。

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-11-04 04:46:47 +08:00
parent fc7c7ff42e
commit eacf54091d
3 changed files with 120 additions and 14 deletions

View File

@ -5047,6 +5047,7 @@ class PendingOrderService extends OrderBaseService {
* 批量锁定订单(异步任务模式)。
*
* 将给定订单的 lock_status 批量更新为 'warehouse',并写入操作日志 ORDER_LOCK。
* 已取消订单不允许锁定,后台任务会跳过并通过 skipped_cancelled_order_ids 返回。
* 仅操作当前仓库上下文内的订单,每批最多 500 条。
*
* @param {Object} data 请求参数。
@ -5163,6 +5164,8 @@ class PendingOrderService extends OrderBaseService {
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.processed_order_count = Number(cachedProgress.processed_order_count || 0);
payload.locked_order_count = Number(cachedProgress.locked_order_count || 0);
payload.skipped_cancelled_order_count = Number(cachedProgress.skipped_cancelled_order_count || 0);
payload.skipped_cancelled_order_ids = this.normalizeIdsInput(cachedProgress.skipped_cancelled_order_ids);
}
if (state === 'success') {
@ -5171,6 +5174,8 @@ class PendingOrderService extends OrderBaseService {
payload.total_order_count = Number(result.total_order_count || 0);
payload.locked_order_count = Number(result.locked_order_count || 0);
payload.locked_order_ids = this.normalizeIdsInput(result.locked_order_ids);
payload.skipped_cancelled_order_count = Number(result.skipped_cancelled_order_count || 0);
payload.skipped_cancelled_order_ids = this.normalizeIdsInput(result.skipped_cancelled_order_ids);
payload.duration_ms = Number(result.duration_ms || cachedProgress.duration_ms || 0);
}
@ -5178,6 +5183,7 @@ class PendingOrderService extends OrderBaseService {
payload.progress_percent = Number(cachedProgress.progress_percent || 0);
payload.total_order_count = Number(cachedProgress.total_order_count || 0);
payload.locked_order_count = Number(cachedProgress.locked_order_count || 0);
payload.skipped_cancelled_order_count = Number(cachedProgress.skipped_cancelled_order_count || 0);
payload.error_message = String(cachedProgress.error || '').trim();
payload.error_code = String(cachedProgress.error_code || '').trim() || 'BATCH_LOCK_FAILED';
payload.duration_ms = Number(cachedProgress.duration_ms || 0);
@ -5315,6 +5321,7 @@ class PendingOrderService extends OrderBaseService {
* 执行批量锁定后台任务。
*
* 直接对给定订单ID数组,将 lock_status 更新为 'warehouse',并写入操作日志 ORDER_LOCK。
* 已取消(status='cancel')订单为终态,不参与锁定,会通过 skipped_cancelled_order_ids 透出。
* 仅处理当前仓库上下文内的订单,每批最多 500 条。
*
* @param {Object} params 任务参数。
@ -5393,7 +5400,7 @@ class PendingOrderService extends OrderBaseService {
}
const orderRows = await orderModel.findAll({
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code' ],
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'status' ],
where: {
warehouse_id: warehouseId,
id: {
@ -5409,17 +5416,34 @@ class PendingOrderService extends OrderBaseService {
}
const lockedOrderIds = [];
const skippedCancelledOrderIds = [];
const operator = this.getOrderLogOperator();
const logWarehouseId = this.getOrderLogWarehouseId(warehouseId);
const normalizedOrderRows = Array.isArray(validOrderRows) ? validOrderRows : [];
// 已取消订单为终态,不能再锁定;锁定后再解锁会让订单停留在取消态且带上锁定标记,无法正常出库
const lockableOrderRows = [];
for (const row of normalizedOrderRows) {
const orderId = Number(row && row.id);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
if (String(row && row.status || '').trim() === PENDING_CANCEL_STATUS) {
skippedCancelledOrderIds.push(orderId);
continue;
}
lockableOrderRows.push(row);
}
const totalOrderCount = orderIds.length;
const validOrderCount = normalizedOrderRows.length;
const validOrderCount = lockableOrderRows.length;
await this.setBatchLockTaskProgress(normalizedTaskId, 'running', {
warehouse_id: warehouseId,
total_order_count: totalOrderCount,
valid_order_count: validOrderCount,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
});
if (validOrderCount === 0) {
@ -5428,6 +5452,8 @@ class PendingOrderService extends OrderBaseService {
warehouse_id: warehouseId,
total_order_count: totalOrderCount,
locked_order_count: 0,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
@ -5436,8 +5462,12 @@ class PendingOrderService extends OrderBaseService {
locked_order_ids: [],
locked_order_count: 0,
total_order_count: totalOrderCount,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
duration_ms: durationMs,
message: '未找到可锁定的当前仓库订单',
message: skippedCancelledOrderIds.length > 0
? `所选订单均已取消,已跳过 ${skippedCancelledOrderIds.length} 条,不能锁定`
: '未找到可锁定的当前仓库订单',
},
});
return;
@ -5445,8 +5475,8 @@ class PendingOrderService extends OrderBaseService {
// 分批更新锁定状态,每批最多500条
const UPDATE_CHUNK_SIZE = 500;
for (let i = 0; i < normalizedOrderRows.length; i += UPDATE_CHUNK_SIZE) {
const chunkRows = normalizedOrderRows.slice(i, i + UPDATE_CHUNK_SIZE);
for (let i = 0; i < lockableOrderRows.length; i += UPDATE_CHUNK_SIZE) {
const chunkRows = lockableOrderRows.slice(i, i + UPDATE_CHUNK_SIZE);
if (chunkRows.length === 0) {
continue;
}
@ -5462,16 +5492,50 @@ class PendingOrderService extends OrderBaseService {
updated_at: now,
};
await orderModel.update(updateValues, {
const updateResult = await orderModel.update(updateValues, {
where: {
id: {
[Op.in]: chunkOrderIds,
},
status: {
[Op.ne]: PENDING_CANCEL_STATUS,
},
},
});
const affectedCount = Number(Array.isArray(updateResult) ? updateResult[0] : updateResult) || 0;
// 查询与更新之间订单可能被取消:回查确认真正落库的订单,避免为未更新成功的订单写锁定日志
let updatedRows = chunkRows;
if (affectedCount < chunkOrderIds.length) {
const confirmedRows = await orderModel.findAll({
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'status' ],
where: {
warehouse_id: warehouseId,
id: {
[Op.in]: chunkOrderIds,
},
},
raw: true,
});
const confirmedOrderIds = new Set();
for (const row of (Array.isArray(confirmedRows) ? confirmedRows : [])) {
const orderId = Number(row && row.id);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
if (String(row && row.status || '').trim() === PENDING_CANCEL_STATUS) {
if (!skippedCancelledOrderIds.includes(orderId)) {
skippedCancelledOrderIds.push(orderId);
}
continue;
}
confirmedOrderIds.add(orderId);
}
updatedRows = chunkRows.filter(row => confirmedOrderIds.has(Number(row.id)));
}
// 写入操作日志 ORDER_LOCK
const logPayloads = chunkRows.map(row => {
const logPayloads = updatedRows.map(row => {
const orderId = Number(row.id || 0);
const orderNo = String(row.delivery_order_code || row.pre_delivery_order_code || '').trim();
if (!Number.isInteger(orderId) || orderId <= 0) {
@ -5506,8 +5570,11 @@ class PendingOrderService extends OrderBaseService {
}
}
for (const orderId of chunkOrderIds) {
lockedOrderIds.push(orderId);
for (const row of updatedRows) {
const orderId = Number(row.id);
if (Number.isInteger(orderId) && orderId > 0) {
lockedOrderIds.push(orderId);
}
}
// 更新进度
@ -5519,6 +5586,8 @@ class PendingOrderService extends OrderBaseService {
warehouse_id: warehouseId,
total_order_count: totalOrderCount,
locked_order_count: lockedOrderIds.length,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
progress_percent: progressPercent,
});
}
@ -5528,6 +5597,8 @@ class PendingOrderService extends OrderBaseService {
warehouse_id: warehouseId,
total_order_count: totalOrderCount,
locked_order_count: lockedOrderIds.length,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
progress_percent: 100,
end_time: Date.now(),
duration_ms: durationMs,
@ -5536,8 +5607,12 @@ class PendingOrderService extends OrderBaseService {
locked_order_ids: lockedOrderIds,
locked_order_count: lockedOrderIds.length,
total_order_count: totalOrderCount,
skipped_cancelled_order_ids: skippedCancelledOrderIds,
skipped_cancelled_order_count: skippedCancelledOrderIds.length,
duration_ms: durationMs,
message: `已锁定 ${lockedOrderIds.length} 条订单`,
message: skippedCancelledOrderIds.length > 0
? `已锁定 ${lockedOrderIds.length} 条订单,已跳过 ${skippedCancelledOrderIds.length} 条已取消订单`
: `已锁定 ${lockedOrderIds.length} 条订单`,
},
});
} catch (error) {

View File

@ -1,4 +1,23 @@
[
{
"version": "0.3.322",
"date": "2026-11-02",
"type": "updated",
"summary": "订单批量锁定跳过已取消订单:order.pendingOrder.batchLock 后台任务不再锁定 status=cancel 的订单,避免取消订单被锁定后无法出库;新增 skipped_cancelled_order_count / skipped_cancelled_order_ids 透出跳过明细",
"methods": [
"order.pendingOrder.batchLock",
"order.pendingOrder.batchLockTaskProgress"
],
"notes": [
"背景:奇门取消订单(ORDER_CANCEL,status=cancel)后,网页后台仍可对该订单执行订单锁定(ORDER_LOCK)。取消订单被锁定后会残留锁定标记,导致订单无法按取消逻辑正常出库。",
"现口径:runBatchLockTask 查询订单时带出 status,status=cancel 的订单不进入锁定更新,也不写入 ORDER_LOCK 操作日志;混合批次只锁定未取消订单。",
"并发保护:更新语句 where 增加 status != 'cancel';若更新影响行数少于目标行数,回查确认实际落库订单,只为确认锁定的订单写日志与计数。",
"返回:batchLockTaskProgress 在 running/success/failed 返回 skipped_cancelled_order_count,running/success 返回 skipped_cancelled_order_ids;success.result.message 存在跳过项时提示「已跳过 N 条已取消订单」,全部为取消订单时提示「所选订单均已取消,已跳过 N 条,不能锁定」。",
"兼容性:入参未变;解锁(order.pendingOrder.batchUnlock)仍可对已取消订单执行,便于清理历史锁定状态。",
"测试:test/app/service/systemMethods/order/pendingOrder.batchLock.cancel.test.js 新增 4 条用例(混合批次跳过取消单、全部取消不更新、进度接口返回跳过明细、更新期间并发取消不写日志)。",
"代码依据:app/service/systemMethods/order/pendingOrder.js#runBatchLockTask/#batchLockTaskProgress。"
]
},
{
"version": "0.3.321",
"date": "2026-10-28",

View File

@ -1,8 +1,8 @@
{
"module": "system",
"description": "系统接口标准入口,method 对应系统内置方法,全部使用 POST 请求,参数统一放在 body 内",
"version": "0.3.321",
"updatedAt": "2026-10-28",
"version": "0.3.322",
"updatedAt": "2026-11-02",
"headers": [
{
"name": "platform",
@ -5906,7 +5906,7 @@
},
{
"method": "order.pendingOrder.batchLock",
"description": "批量提交订单锁定请求(异步任务模式)。接收订单ID数组,提交后立即返回 task_id 和受理信息,后端异步将每个订单的 lock_status 更新为 'warehouse' 并写入操作日志(ORDER_LOCK)。相同 task_id 幂等提交会返回已存在任务的信息。仓库ID统一使用当前上下文(ctx.user.store_id)。",
"description": "批量提交订单锁定请求(异步任务模式)。接收订单ID数组,提交后立即返回 task_id 和受理信息,后端异步将每个订单的 lock_status 更新为 'warehouse' 并写入操作日志(ORDER_LOCK)。已取消订单(status=cancel)为终态不可锁定,后台任务会跳过并通过 skipped_cancelled_order_ids 返回,避免取消订单被重新锁定后无法正常出库。相同 task_id 幂等提交会返回已存在任务的信息。仓库ID统一使用当前上下文(ctx.user.store_id)。",
"isNeedAuth": false,
"isNeedLogin": true,
"headers": [
@ -5984,7 +5984,7 @@
},
{
"method": "order.pendingOrder.batchLockTaskProgress",
"description": "查询批量锁定任务进度。根据 task_id 返回任务的当前状态、进度百分比、已处理/已锁定订单数等信息。任务状态 state 包含 submitted(已提交)、running(执行中)、success(已完成)、failed(失败)、not_found(未找到)。",
"description": "查询批量锁定任务进度。根据 task_id 返回任务的当前状态、进度百分比、已处理/已锁定订单数等信息。任务状态 state 包含 submitted(已提交)、running(执行中)、success(已完成)、failed(失败)、not_found(未找到)。已取消订单不参与锁定,通过 skipped_cancelled_order_count / skipped_cancelled_order_ids 返回跳过数量与订单ID。",
"isNeedAuth": false,
"isNeedLogin": true,
"headers": [
@ -6071,6 +6071,18 @@
"required": false,
"description": "已锁定订单ID列表(仅 success 时返回)"
},
{
"name": "skipped_cancelled_order_count",
"type": "number",
"required": false,
"description": "因订单已取消而跳过的数量(submitted/running/success/failed 时返回,success 时取结果值)"
},
{
"name": "skipped_cancelled_order_ids",
"type": "number[]",
"required": false,
"description": "因订单已取消而跳过的订单ID列表(submitted/running/success 时返回)"
},
{
"name": "duration_ms",
"type": "number",