fix(workbench): 打包与查订单改按订单主键定位,不再按发货单号反查(防跨货主串单)

背景:wms_order_delivery 唯一索引是 (delivery_order_code, store_id, warehouse_id),
跨货主可重复,按「发货单号 + 仓库」反查订单在撞号时会把打包记到别的货主的订单上。
生产案例:发货单号 1345551 同仓命中团购单 306715 与散单 1096062,
打包记录因此落到 306715(团购波次 B2026082911192),而波次号字符串却取了扫码单的 E2026101300061。

- workbench._packOrder 新增 order_id 入参:优先按订单主键查单(current → dispatch 分表遍历),
  主键未命中才按 delivery_order_code 兜底;
- key 模式透传后端扫码上下文的主键:business(packOrder) 与 packOrderByToken 均带上 cachedCtx.order_id;
- 旧参数模式从设备上报 body 中剥离 order_id(只信任后端缓存注入,防篡改);
- 主键与发货单号不一致时打 warn 留痕,落库字段与响应结构不变;
- inbox 查订单:运单号命中后的订单定位与关联运单查询改为按订单主键(id / order_id)。

未改动(已核查,属创建查重 / 用户按单号搜索入口 / 外部接口契约 / 只读展示)。
This commit is contained in:
liufumingren 2026-10-13 23:54:54 +08:00
parent 16134e88c6
commit e602d205b2
2 changed files with 74 additions and 23 deletions

View File

@ -800,8 +800,25 @@ class InboxFunctionsService extends Service {
} catch (_err) { /* 定位失败,降级三表遍历 */ }
}
if (!found) {
// 用运单关联的发货单号精确查找订单
if (!found && exactOrderId > 0) {
// 序列表未命中 → 三表按订单主键遍历(主键唯一,避免按发货单号跨货主串单)
for (const cfg of tableConfigs) {
const model = await cfg.getModel(factory, warehouseId);
if (!model) continue;
const row = await model.findOne({
attributes,
where: { id: exactOrderId, store_id: storeId },
raw: true,
});
if (row) {
found = { table: cfg.key, table_label: cfg.label, ...row };
break;
}
}
}
if (!found && exactExpress.delivery_order_code) {
// 兼容历史运单(order_id 缺失)时按发货单号兜底;已限定 store_id,单号唯一
found = await findInDeliveryTables({
store_id: storeId,
delivery_order_code: exactExpress.delivery_order_code,
@ -827,12 +844,12 @@ class InboxFunctionsService extends Service {
};
}
// ========== 第三步:查关联运单信息 ==========
// ========== 第三步:查关联运单信息(按订单主键,不用发货单号)==========
const linkedExpress = await ctx.model.OrderExpress.findAll({
attributes: [ 'waybill_code', 'logistics_name', 'weighing_weight', 'status', 'is_galaxy_receive' ],
where: {
delivery_order_code: found.delivery_order_code,
store_id: storeId,
order_id: found.id,
warehouse_id: warehouseId,
},
raw: true,
});

View File

@ -259,6 +259,7 @@ class WorkbenchService extends Service {
const cachedCtx = await this._loadPackCtx(bizData);
return await this._packOrder({
delivery_order_code: cachedCtx.delivery_order_code,
order_id: cachedCtx.order_id,
wave_no: cachedCtx.wave_no,
wave_scope: cachedCtx.wave_scope,
waybill_code: cachedCtx.waybill_code,
@ -266,7 +267,10 @@ class WorkbenchService extends Service {
workbench_id: cachedCtx.workbench_id != null ? Number(cachedCtx.workbench_id) : null,
});
}
return await this._packOrder(bizData);
// 旧参数模式:order_id 不接受设备上报(仅 key 模式由后端缓存注入,防篡改),
// 避免设备用外部键/主键交叉传参造成查单口径漂移
const { order_id: _ignoredOrderId, ...legacyPackParams } = bizData;
return await this._packOrder(legacyPackParams);
}
case 'finishPack':
return await this._finishPack(data || {});
@ -789,14 +793,16 @@ class WorkbenchService extends Service {
* 服务端复查落库,防止前端失真;写入 wms_pack_task.wave_scope。
* 响应附大团购倒计时字段:wave_scope=1 时下发 pack_wait_seconds(大团购打包系数 × 当前波次打包数 ÷ 当前工作台打包人数,秒)
* 与 pack_start_time(开始打包时间,毫秒时间戳)供前端倒计时;其他波次两字段均为 0。
* @param {Object} params - { delivery_order_code, wave_no, wave_scope, warehouse_id, workbench_id, status, pack_time, waybill_code, users }
* @param {Object} params - { delivery_order_code, order_id, wave_no, wave_scope, warehouse_id, workbench_id, status, pack_time, waybill_code, users }
* @param {number} [params.order_id] 订单主键(key 模式由扫码上下文注入,优先用它定位订单;
* 发货单号唯一性仅为「单号+货主+仓库」,跨货主可重复,不作为首选查单键)
* @param {string} [params.waybill_code] 扫描打包的运单号(可选,用于运单维度记录流水)
* @param {number} [params.wave_scope] 波次范围(0未分配 1大团购 2散单 3小团购 4单品单件,可选)
* @returns {Promise<Object>} 打包结果 { task_id, order_id, delivery_order_code, wave_no, isSandan, pack_mode, status, pack_wait_seconds, pack_start_time, batch? }
*/
async _packOrder(params) {
const { ctx } = this;
const { delivery_order_code: deliveryOrderCode, wave_no: waveNo,
const { delivery_order_code: deliveryOrderCode, order_id: orderIdParam, wave_no: waveNo,
wave_scope: waveScopeParam,
warehouse_id: inputWarehouseId, workbench_id: workbenchIdRaw,
status: packStatus, pack_time: packTime,
@ -806,7 +812,9 @@ class WorkbenchService extends Service {
waybill_code: waybillCodeParam,
users: usersParam } = params;
if (!deliveryOrderCode) throw new Error('发货单号不能为空');
if (!deliveryOrderCode && !(Number.isInteger(Number(orderIdParam)) && Number(orderIdParam) > 0)) {
throw new Error('发货单号不能为空');
}
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
@ -819,28 +827,49 @@ class WorkbenchService extends Service {
: null;
const packTimeMs = packTime ? Number(packTime) * 1000 : Date.now();
// 步骤1:查找订单
// 步骤1:查找订单(current → dispatch 分表遍历)
// 优先按订单主键定位:发货单号唯一索引为 (delivery_order_code, store_id, warehouse_id),
// 跨货主可重复,按「发货单号 + 仓库」反查在撞号时会串到别的货主的订单(历史缺陷);
// 仅在无 order_id(旧参数模式)或主键未命中时,才按发货单号兜底。
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const normalizedOrderIdParam = Number(orderIdParam);
const hasOrderIdParam = Number.isInteger(normalizedOrderIdParam) && normalizedOrderIdParam > 0;
let orderRow = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const row = await model.findOne({
where: { delivery_order_code: deliveryOrderCode, warehouse_id: warehouseId },
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
const findOneInTables = async where => {
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const row = await model.findOne({ where, raw: true });
if (row) return row;
} catch (_err) { continue; }
}
return null;
};
const orderByPrimaryKey = hasOrderIdParam
? await findOneInTables({ id: normalizedOrderIdParam, warehouse_id: warehouseId })
: null;
const orderRow = orderByPrimaryKey
|| await findOneInTables({ delivery_order_code: deliveryOrderCode, warehouse_id: warehouseId });
if (!orderRow) throw new Error(`未找到发货单 [${deliveryOrderCode}]`);
// 主键与发货单号反查结果不一致时留痕(主键优先,防止串单)
if (hasOrderIdParam && Number(orderRow.id) !== normalizedOrderIdParam) {
ctx.logger.warn('[Workbench._packOrder] order_id 未命中、改按发货单号兜底命中 orderIdParam=%d hitOrderId=%d deliveryOrderCode=%s',
normalizedOrderIdParam, Number(orderRow.id), deliveryOrderCode);
}
if (deliveryOrderCode && orderRow.delivery_order_code
&& String(orderRow.delivery_order_code) !== String(deliveryOrderCode)) {
ctx.logger.warn('[Workbench._packOrder] 发货单号与命中订单不一致,以订单主键为准 orderId=%d passed=%s hit=%s',
Number(orderRow.id), deliveryOrderCode, orderRow.delivery_order_code);
}
const orderId = orderRow.id;
const waveId = orderRow.wave_id || 0;
const actualWaveNo = waveNo || orderRow.wave_no || '';
@ -3947,11 +3976,16 @@ class WorkbenchService extends Service {
}
packParams = {
delivery_order_code: cachedCtx.delivery_order_code,
// 订单主键由后端扫码上下文注入:发货单号唯一性仅为 (单号, 货主, 仓库),
// 跨货主可重复,按单号+仓库反查会串单,故打包以主键为准
order_id: cachedCtx.order_id,
wave_no: cachedCtx.wave_no,
waybill_code: cachedCtx.waybill_code,
};
} else {
packParams = legacyParams || {};
// 旧参数模式:order_id 不接受设备上报(仅 key 模式由后端缓存注入,防篡改)
const { order_id: _ignoredOrderId, ...restLegacyParams } = legacyParams || {};
packParams = restLegacyParams;
}
const result = await this._packOrder({