fix: 手工运单号防误删三层防护 + 操作日志businessId修正

1. hardDeleteWaybillAsyncOrderExpressRows 加 status:0 过滤,保护手工录入 status=1 记录
2. createWaybillCodePipeline 入口跳过 business_key=1 且已分配运单的订单
3. manualWaybill 操作日志 businessId 从仓库ID 修正为订单ID String(orderId)
4. 新增 14 个单元测试,全部通过
This commit is contained in:
liufumingren 2026-07-07 17:06:43 +08:00
parent 88df30c862
commit 19f0449992
5 changed files with 714 additions and 3 deletions

View File

@ -5579,7 +5579,7 @@ class PendingOrderService extends OrderBaseService {
try {
await this.ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: logWarehouseId,
businessId: String(orderId),
operationCode: 'ORDER_MANUAL_WAYBILL',
operator,
extras: {

View File

@ -2216,7 +2216,7 @@ class ExpressService extends Service {
/**
* 硬删除运单异步失败分组对应的订单快递记录。
* 硬删除运单异步失败分组对应的订单快递记录(仅删除 status=0 的未完成记录,保护手工录入等已完成记录)。
*
* 删除条件必须同时包含订单ID和业务键,若任一订单缺少 business_key,则记录原因并跳过整个分组,避免误删。
*
@ -2279,6 +2279,7 @@ class ExpressService extends Service {
await orderExpressModel.destroy({
where: {
[Op.or]: deleteConditions,
status: 0,
},
});
return true;
@ -2370,8 +2371,58 @@ class ExpressService extends Service {
inputOrderCount: orderList.length,
matchedOrderCount: Array.isArray(orders_arr) ? orders_arr.length : 0,
});
// 【step1.5】过滤已分配运单号(status=1)且传入 business_key=1 的订单,避免重复分配。
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
let filteredOrdersArr = orders_arr;
if (orderExpressModel && orders_arr.length > 0) {
const orderIds = orders_arr.map(o => Number(o.id)).filter(id => id > 0);
const completedRows = await orderExpressModel.findAll({
where: {
order_id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
status: 1,
},
attributes: [ 'order_id', 'business_key' ],
raw: true,
});
const skipSet = new Set();
for (const row of completedRows) {
skipSet.add(`${Number(row.order_id)}:${Number(row.business_key)}`);
}
if (skipSet.size > 0) {
const beforeCount = orders_arr.length;
filteredOrdersArr = orders_arr.filter(order => {
const matchedExpress = orderList.find(express => Number(order.id) === Number(express.order_id));
const businessKey = matchedExpress ? Number(matchedExpress.business_key) : 1;
if (businessKey === 1 && skipSet.has(`${Number(order.id)}:1`)) {
return false;
}
return true;
});
if (filteredOrdersArr.length < beforeCount) {
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 跳过已分配运单号(business_key=1)的订单', {
traceId,
skippedCount: beforeCount - filteredOrdersArr.length,
skippedOrderIds: orders_arr
.filter(order => {
const matchedExpress = orderList.find(express => Number(order.id) === Number(express.order_id));
const businessKey = matchedExpress ? Number(matchedExpress.business_key) : 1;
return businessKey === 1 && skipSet.has(`${Number(order.id)}:1`);
})
.map(o => o.id),
});
}
}
}
if (filteredOrdersArr.length === 0) {
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 所有订单均已分配运单号,无需处理', { traceId });
return { message: '所有订单均已分配运单号,无需处理' };
}
// orders_arr和orderList合并
const ordersWithExpress = orders_arr.map(order => {
const ordersWithExpress = filteredOrdersArr.map(order => {
const matchedExpress = orderList.find(express => Number(order.id) === Number(express.order_id));
return {
...order,

View File

@ -0,0 +1,180 @@
'use strict';
const assert = require('node:assert/strict');
const PendingOrderService = require('../../../../../app/service/systemMethods/order/pendingOrder');
/**
* 创建 manualWaybill 操作日志回归测试上下文。
*
* 仅覆盖 operationLog.createOperationLog 的 businessId 传入值。
*/
function createManualWaybillLogHarness(options = {}) {
const calls = {
operationLogPayload: null,
orderExpressCreatePayload: null,
orderDeliveryUpdatePayload: null,
syncOrderIdsPayload: null,
};
const warehouseId = options.warehouseId || 100000;
const testOrderId = options.orderId || 999001;
const orderRow = {
id: testOrderId,
step: options.orderStep || 1,
outbound_status: options.outboundStatus || 'none',
warehouse_id: warehouseId,
store_id: options.storeId || 1000000,
};
const orderExpressMax = options.orderExpressMax !== undefined ? options.orderExpressMax : null;
const ctx = {
app: {
Sequelize: {
Op: {
in: 'in',
},
},
},
user: {
store_id: warehouseId,
employees_id: '9001',
employees_name: '测试员',
},
model: {
OrderExpress: {
async max(field, whereOptions) {
return orderExpressMax;
},
async create(values) {
calls.orderExpressCreatePayload = values;
return {
id: 10001,
...values,
};
},
},
OrderDeliveryFactory: {
getCurrentModel: () => {
throw new Error('应使用 getOrderModel,不是 OrderDeliveryFactory');
},
},
},
service: {
systems: {
operationLog: {
async createOperationLog(payload) {
calls.operationLogPayload = payload;
return { id: 1 };
},
},
storeWarehouse: {
async getContractConfig() {
return null;
},
},
},
},
logger: {
info() {},
warn() {},
error() {},
},
};
const service = new PendingOrderService(ctx);
// 注入 mock getOrderModel / buildOrderWhere / success / getWarehouseId
service.getWarehouseId = () => warehouseId;
service.getOrderLogOperator = () => ({
id: ctx.user && ctx.user.employees_id,
name: ctx.user && ctx.user.employees_name,
});
service.getOrderLogWarehouseId = () => warehouseId;
service.getOrderModel = async () => ({
async findOne(query) {
return orderRow;
},
async update(values, whereOpts) {
calls.orderDeliveryUpdatePayload = { values, where: whereOpts.where };
return [ 1 ];
},
});
service.buildOrderWhere = (orderIds) => ({
id: { [ctx.app.Sequelize.Op.in]: orderIds },
warehouse_id: warehouseId,
});
service.success = (msg, data) => ({ code: 0, msg, data });
service.syncOrderIds = (payload) => {
calls.syncOrderIdsPayload = payload;
return Promise.resolve();
};
return { service, calls, ctx };
}
describe('test/app/service/systems/express.manualWaybill.guard.test.js — manualWaybill 操作日志', () => {
it('createOperationLog 的 businessId 应为 String(orderId),而非仓库ID', async () => {
const testOrderId = 888001;
const { service, calls } = createManualWaybillLogHarness({
orderId: testOrderId,
warehouseId: 100000,
});
await service.manualWaybill({
order_id: testOrderId,
waybill_code: 'SF1234567890',
});
assert.ok(calls.operationLogPayload, '应调用 createOperationLog');
assert.equal(calls.operationLogPayload.businessType, 'order');
assert.equal(calls.operationLogPayload.businessId, String(testOrderId),
`businessId 应为订单ID "${testOrderId}",而非仓库ID`);
assert.equal(calls.operationLogPayload.operationCode, 'ORDER_MANUAL_WAYBILL');
assert.equal(calls.operationLogPayload.extras.warehouseId, 100000);
assert.equal(calls.operationLogPayload.extras.orderId, testOrderId);
assert.equal(calls.operationLogPayload.extras.waybillCode, 'SF1234567890');
});
it('businessId 不应为 warehouseId(回归验证)', async () => {
const testOrderId = 888002;
const warehouseId = 100000;
const { service, calls } = createManualWaybillLogHarness({
orderId: testOrderId,
warehouseId,
});
await service.manualWaybill({
order_id: testOrderId,
waybill_code: 'YT9876543210',
});
assert.ok(calls.operationLogPayload, '应调用 createOperationLog');
assert.notEqual(calls.operationLogPayload.businessId, String(warehouseId),
`businessId 不应为仓库ID "${warehouseId}"`);
assert.equal(calls.operationLogPayload.businessId, String(testOrderId),
`businessId 应为订单ID "${testOrderId}"`);
});
it('business_key 从已有最大值递增', async () => {
const testOrderId = 888003;
const { service, calls } = createManualWaybillLogHarness({
orderId: testOrderId,
orderExpressMax: 3,
});
await service.manualWaybill({
order_id: testOrderId,
waybill_code: 'EMS0000000001',
});
assert.ok(calls.orderExpressCreatePayload);
assert.equal(calls.orderExpressCreatePayload.business_key, 4, '应从 max(3)+1=4 递增');
assert.equal(calls.orderExpressCreatePayload.status, 1, '手工录入 status 应为 1');
});
});

View File

@ -0,0 +1,407 @@
'use strict';
const assert = require('node:assert/strict');
const ExpressService = require('../../../../app/service/systems/express');
// ============================================================================
// Harness: hardDeleteWaybillAsyncOrderExpressRows
// ============================================================================
function createHardDeleteHarness(options = {}) {
const calls = {
destroyCount: 0,
destroyWhere: null,
loggerErrors: [],
};
const orderExpressModel = {
async destroy(whereOptions) {
calls.destroyCount += 1;
calls.destroyWhere = whereOptions;
if (typeof options.destroy === 'function') {
return await options.destroy(whereOptions);
}
return 1;
},
};
const ctx = {
app: {
Sequelize: {
Op: {
or: 'or',
},
},
},
model: {
OrderExpress: options.orderExpressModel !== undefined ? options.orderExpressModel : orderExpressModel,
},
logger: {
info() {},
warn() {},
error(...args) {
calls.loggerErrors.push(args);
},
},
};
const service = new ExpressService(ctx);
return { service, calls, ctx };
}
// ============================================================================
// Harness: createWaybillCodePipeline — skip business_key=1 + status=1
// ============================================================================
function createPipelineSkipHarness(options = {}) {
const calls = {
asyncTaskPayloads: [],
printPlatformFindAllQueries: [],
listByWarehousePlatformCodePayloads: [],
orderExpressFindAllQueries: [],
loggerInfoMessages: [],
};
const orderDeliveryRows = Array.isArray(options.orderDeliveryRows)
? options.orderDeliveryRows
: [
{
id: 1,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
{
id: 2,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
];
const orderExpressRows = Array.isArray(options.orderExpressRows)
? options.orderExpressRows
: [];
const platformList = Array.isArray(options.platformList) ? options.platformList : [{
code: 'PDD',
print_platform_id: 901,
default_express_interface: 'POLYAPI',
}];
const printPlatformRows = Array.isArray(options.printPlatformRows) ? options.printPlatformRows : [
{
id: 901,
platform_code: 'PDD_PRINT',
request_platform_code: 'OPEN_API',
},
];
const listData = Array.isArray(options.listData) ? options.listData : [];
const ctx = {
app: {
Sequelize: {
Op: {
in: 'in',
},
},
},
user: {
store_id: 100000,
},
model: {
OrderExpress: {
async findAll(query) {
calls.orderExpressFindAllQueries.push(query);
return orderExpressRows;
},
},
OrderDeliveryFactory: {
async getCurrentModel() {
return {
async findAll() {
return orderDeliveryRows;
},
async update() {
return [ 1 ];
},
};
},
},
PrintPlatform: {
async findAll(query) {
calls.printPlatformFindAllQueries.push(query);
return printPlatformRows;
},
},
},
service: {
systems: {
platform: {
async getPlatformList() {
return platformList;
},
},
setting: {
expressInterface: {
async listByWarehousePlatformCode(payload) {
calls.listByWarehousePlatformCodePayloads.push(payload);
return { data: listData };
},
},
},
},
},
logger: {
info(...args) {
calls.loggerInfoMessages.push(args.map(a => String(a)).join(' '));
},
warn() {},
error() {},
},
};
const service = new ExpressService(ctx);
service.asyncTask = (batch, opts, matchedPlatform, expressInterfaceConfig) => {
calls.asyncTaskPayloads.push({ batch, opts, matchedPlatform, expressInterfaceConfig });
};
return { service, calls, ctx };
}
// ============================================================================
// Tests: hardDeleteWaybillAsyncOrderExpressRows
// ============================================================================
describe('test/app/service/systems/express.manualWaybill.guard.test.js', () => {
describe('hardDeleteWaybillAsyncOrderExpressRows — status:0 过滤', () => {
it('destroy 应包含 status:0 条件,保护 status=1 的手工记录', async () => {
const { service, calls } = createHardDeleteHarness();
await service.hardDeleteWaybillAsyncOrderExpressRows(
[
{ order_id: 100, business_key: 1 },
{ order_id: 200, business_key: 2 },
],
{ platform_code: 'PDD', error_message: '测试失败' }
);
assert.equal(calls.destroyCount, 1);
assert.ok(calls.destroyWhere, 'destroy 应被调用');
assert.ok(calls.destroyWhere.where, 'where 条件应存在');
assert.equal(calls.destroyWhere.where.status, 0, 'status 必须为 0');
assert.ok(Array.isArray(calls.destroyWhere.where.or), 'or 条件应存在');
assert.equal(calls.destroyWhere.where.or.length, 2);
});
it('缺少 business_key 时应返回 false,不调用 destroy', async () => {
const { service, calls } = createHardDeleteHarness();
const result = await service.hardDeleteWaybillAsyncOrderExpressRows(
[{ order_id: 100 }],
{ platform_code: 'JD' }
);
assert.equal(result, false);
assert.equal(calls.destroyCount, 0, '缺少 business_key 不应调用 destroy');
});
it('缺少 order_id 时应返回 false,不调用 destroy', async () => {
const { service, calls } = createHardDeleteHarness();
const result = await service.hardDeleteWaybillAsyncOrderExpressRows(
[{ business_key: 1 }],
{ platform_code: 'JD' }
);
assert.equal(result, false);
assert.equal(calls.destroyCount, 0);
});
it('OrderExpress 模型不可用时应返回 false', async () => {
const { service, calls } = createHardDeleteHarness({
orderExpressModel: null,
});
const result = await service.hardDeleteWaybillAsyncOrderExpressRows(
[{ order_id: 100, business_key: 1 }],
{}
);
assert.equal(result, false);
assert.equal(calls.destroyCount, 0);
});
it('空数组应返回 false', async () => {
const { service, calls } = createHardDeleteHarness();
const result = await service.hardDeleteWaybillAsyncOrderExpressRows([], {});
assert.equal(result, false);
assert.equal(calls.destroyCount, 0);
});
it('destroy 抛异常时应返回 false 并记录错误日志', async () => {
const { service, calls } = createHardDeleteHarness({
destroy: async () => {
throw new Error('DB 连接失败');
},
});
const result = await service.hardDeleteWaybillAsyncOrderExpressRows(
[{ order_id: 100, business_key: 1 }],
{ platform_code: 'PDD', error_message: 'err' }
);
assert.equal(result, false);
assert.equal(calls.destroyCount, 1);
assert.ok(calls.loggerErrors.length > 0, '应记录错误日志');
});
});
// ==========================================================================
// Tests: createWaybillCodePipeline — 跳过已分配运单的订单
// ==========================================================================
describe('createWaybillCodePipeline — 跳过 business_key=1 已分配订单', () => {
it('订单已有 status=1 且传入 business_key=1 时,应跳过该订单', async () => {
const { service, calls } = createPipelineSkipHarness({
orderDeliveryRows: [
{
id: 101,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
{
id: 102,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
],
orderExpressRows: [
{ order_id: 101, business_key: 1, status: 1 },
],
});
await service.createWaybillCodePipeline([
{ order_id: 101, business_key: 1 },
{ order_id: 102, business_key: 1 },
]);
// 订单 101 应被跳过,只有 102 进入 asyncTask
assert.equal(calls.asyncTaskPayloads.length, 1, '只有未分配的订单应进入 asyncTask');
const batch = calls.asyncTaskPayloads[0].batch;
const batchOrderIds = batch.map(o => o.id);
assert.ok(!batchOrderIds.includes(101), '订单 101 不应在 batch 中');
assert.ok(batchOrderIds.includes(102), '订单 102 应在 batch 中');
});
it('订单有 status=1 但传入 business_key=2 时,不应跳过(不同 business_key)', async () => {
const { service, calls } = createPipelineSkipHarness({
orderDeliveryRows: [
{
id: 201,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
],
orderExpressRows: [
{ order_id: 201, business_key: 1, status: 1 },
],
});
await service.createWaybillCodePipeline([
{ order_id: 201, business_key: 2 },
]);
// business_key=2 不同于已完成的 business_key=1,不应跳过
assert.equal(calls.asyncTaskPayloads.length, 1, 'business_key 不同时不应跳过');
});
it('订单有 status=1 但 business_key 不是 1 时,传入 business_key=1 应跳过', async () => {
const { service, calls } = createPipelineSkipHarness({
orderDeliveryRows: [
{
id: 301,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
],
orderExpressRows: [
{ order_id: 301, business_key: 2, status: 1 },
],
});
await service.createWaybillCodePipeline([
{ order_id: 301, business_key: 1 },
]);
// skipSet 中有 "301:2",但过滤条件是 businessKey===1 && skipSet.has("301:1")
// 这里 skipSet 中没有 "301:1",所以不应跳过
assert.equal(calls.asyncTaskPayloads.length, 1, 'skipSet 中无匹配的 business_key=1 时不应跳过');
});
it('全部订单均已完成时,应直接返回无需处理', async () => {
const { service, calls } = createPipelineSkipHarness({
orderDeliveryRows: [
{
id: 401,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
],
orderExpressRows: [
{ order_id: 401, business_key: 1, status: 1 },
],
});
const result = await service.createWaybillCodePipeline([
{ order_id: 401, business_key: 1 },
]);
assert.equal(calls.asyncTaskPayloads.length, 0, '全部跳过时不应调用 asyncTask');
assert.equal(result.message, '所有订单均已分配运单号,无需处理');
});
it('无 status=1 记录时,所有订单正常进入 pipeline', async () => {
const { service, calls } = createPipelineSkipHarness({
orderDeliveryRows: [
{
id: 501,
sys_platform_code: 'PDD',
logistics_code: 'SF',
sys_platform_name: '拼多多',
logistics_name: '顺丰',
store_id: 100000,
},
],
orderExpressRows: [],
});
await service.createWaybillCodePipeline([
{ order_id: 501, business_key: 1 },
]);
assert.equal(calls.asyncTaskPayloads.length, 1, '无已完成记录时所有订单应正常处理');
});
});
});

View File

@ -0,0 +1,73 @@
# 20260707-手工运单号硬删除误删修复单元测试报告
## 测试目标
验证上一轮三轮修复(`hardDeleteWaybillAsyncOrderExpressRows` 加 `status:0` 过滤、`manualWaybill` 操作日志 `businessId` 修正、`createWaybillCodePipeline` 跳过已分配订单)是否符合预期。
## 测试类型
单元测试(Unit Test)
## 测试范围
| 被测方法 | 被测文件 | 测试用例数 | 通过 | 失败 |
|----------|---------|-----------|------|------|
| `hardDeleteWaybillAsyncOrderExpressRows` | `app/service/systems/express.js` | 6 | 6 | 0 |
| `createWaybillCodePipeline` | `app/service/systems/express.js` | 5 | 5 | 0 |
| `manualWaybill` | `app/service/systemMethods/order/pendingOrder.js` | 3 | 3 | 0 |
## 测试产物
- `test/app/service/systems/express.manualWaybill.guard.test.js` — hardDelete + pipeline 跳过逻辑测试
- `test/app/service/systemMethods/order/pendingOrder.manualWaybill.log.test.js` — manualWaybill 操作日志测试
## 测试结果摘要
### ✅ 全部 14 个测试用例通过(0 失败)
### 1. hardDeleteWaybillAsyncOrderExpressRows — status:0 过滤
| 用例 | 结果 |
|------|------|
| destroy 应包含 status:0 条件,保护 status=1 的手工记录 | ✅ PASS |
| 缺少 business_key 时应返回 false,不调用 destroy | ✅ PASS |
| 缺少 order_id 时应返回 false,不调用 destroy | ✅ PASS |
| OrderExpress 模型不可用时应返回 false | ✅ PASS |
| 空数组应返回 false | ✅ PASS |
| destroy 抛异常时应返回 false 并记录错误日志 | ✅ PASS |
### 2. createWaybillCodePipeline — 跳过 business_key=1 已分配订单
| 用例 | 结果 |
|------|------|
| 订单已有 status=1 且传入 business_key=1 时,应跳过该订单 | ✅ PASS |
| 订单有 status=1 但传入 business_key=2 时,不应跳过(不同 business_key) | ✅ PASS |
| 订单有 status=1 但 business_key 不是 1 时,传入 business_key=1 应跳过 | ✅ PASS |
| 全部订单均已完成时,应直接返回无需处理 | ✅ PASS |
| 无 status=1 记录时,所有订单正常进入 pipeline | ✅ PASS |
### 3. manualWaybill — 操作日志 businessId 修正
| 用例 | 结果 |
|------|------|
| createOperationLog 的 businessId 应为 String(orderId),而非仓库ID | ✅ PASS |
| businessId 不应为 warehouseId(回归验证) | ✅ PASS |
| business_key 从已有最大值递增 | ✅ PASS |
## 关键验证点
1. **三层防护闭环验证**:
- 第 1 层(pipeline 入口):`business_key=1` + 已完成的订单在 pipeline 入口即被过滤
- 第 2 层(trans 内):`createWaybillCode` 的 `completedOrderKeySet` 事务内二次校验
- 第 3 层(失败清理):`hardDeleteWaybillAsyncOrderExpressRows` 仅删 `status=0`
2. **操作日志可检索性**:`manualWaybill` 的 `businessId` 已修正为订单 ID,可通过订单 ID 检索操作日志
3. **向后兼容**:
- `business_key ≠ 1` 的已分配订单不会被误跳过
- 无已完成记录时 pipeline 正常运作
## 结论与建议
三轮修复均通过单元测试验证,符合预期行为:
- 手工录入的运单号(`status=1`)不再被失败清理逻辑误删
- 操作日志可正确按订单 ID 检索
- pipeline 入口即过滤已分配订单,避免无效异步任务提交