WMS_MAIN/app/service/systems/order_express.js
liufumingren a8200a3a35 feat(order): 订单拦截全链路阻断与作业排除
- 新增 app/lib/intercept_guard 共享守卫:除 none 外所有拦截状态一律视为已拦截
- 分配波次(singleFetchByIds)/抓取波次(createWavePickTask) 排除拦截订单并回传清单
- 分配储位(allocatePicking)/分配快递(createWaybillCodePipeline、batchAllocateExpress) 跳过拦截订单并回报
- 打印组装(getWavePlatformPrintData/getOrderPrintData/getPrintDataByWaybillCodes) 剔除拦截订单,打印回写/波次反查/标记均排除
- 拣货完成(wavePickTaskComplete) 拦截报错;复核(assertOrderCanRecheck/批量快捷复核) 补全拦截状态
- 打包/称重(workbench、order.updateExpressWeighingWeight) 拦截阻断,波次批量操作排除拦截单
- 绑定包材(order_express) 拦截阻断,波次批量绑定排除拦截单
2026-08-17 21:58:43 +08:00

1951 lines
71 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.

'use strict';
const Service = require('egg').Service;
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
/**
* 订单快递业务服务。
*
* 负责订单快递记录的读取与称重重量更新。
*/
class OrderExpressService extends Service {
/**
* 创建带业务错误码的异常对象。
* @param {string} message 错误信息。
* @param {number} [code=400] 业务错误码。
* @return {Error} 包含 code 的异常对象。
*/
createBusinessError(message, code = 400) {
const error = new Error(`${message}`);
error.code = code;
return error;
}
/**
* 规范化并校验订单ID。
* @param {number|string} orderId 订单ID。
* @return {number} 合法订单ID。
*/
normalizeOrderId(orderId) {
const normalizedOrderId = Number(orderId || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw this.createBusinessError('order_id 必填且必须为正整数', 400);
}
return normalizedOrderId;
}
/**
* 规范化并校验运单号。
* @param {string} waybillCode 运单号。
* @return {string} 合法运单号。
*/
normalizeWaybillCode(waybillCode) {
const normalizedWaybillCode = String(waybillCode || '').trim();
if (!normalizedWaybillCode) {
throw this.createBusinessError('参数错误', 400);
}
return normalizedWaybillCode;
}
/**
* 规范化并校验包材编码。
* @param {string} packageMaterialCode 包材编码。
* @return {string} 合法包材编码。
*/
normalizePackageMaterialCode(packageMaterialCode) {
const normalizedCode = String(packageMaterialCode || '').trim().toUpperCase();
if (!normalizedCode) {
throw this.createBusinessError('参数错误', 400);
}
return normalizedCode;
}
/**
* 规范化并校验包材ID。
* @param {number|string} packageMaterialId 包材ID。
* @return {number} 合法包材ID。
*/
normalizePackageMaterialId(packageMaterialId) {
const normalizedId = Number(packageMaterialId || 0);
if (!Number.isFinite(normalizedId) || normalizedId <= 0) {
throw this.createBusinessError('参数错误', 400);
}
return normalizedId;
}
/**
* 规范化并校验绑定包材场景的订单ID。
* @param {number|string} orderId 订单ID。
* @return {number} 合法订单ID。
*/
normalizeBindOrderId(orderId) {
const normalizedOrderId = Number(orderId || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw this.createBusinessError('参数错误', 400);
}
return normalizedOrderId;
}
/**
* 获取当前仓库 ID。
* @return {number} 当前仓库 ID。
*/
getCurrentWarehouseId() {
const warehouseId = Number(this.ctx && this.ctx.user ? this.ctx.user.store_id : 0);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw this.createBusinessError('参数错误', 400);
}
return warehouseId;
}
/**
* 根据包材ID查询当前仓库启用中的包材。
* @param {number} packageMaterialId 包材ID。
* @param {number} warehouseId 仓库 ID。
* @return {Promise<Object>} 包材记录。
*/
async findActivePackageMaterialById(packageMaterialId, warehouseId) {
const packageMaterialModel = this.ctx.model && this.ctx.model.PackageMaterial;
if (!packageMaterialModel || typeof packageMaterialModel.findOne !== 'function') {
throw this.createBusinessError('包材模型未初始化', 500);
}
const materialRow = await packageMaterialModel.findOne({
where: {
warehouse_id: warehouseId,
id: packageMaterialId,
status: 1,
},
attributes: [ 'id', 'material_code', 'material_name', 'warehouse_id', 'status' ],
raw: true,
});
if (!materialRow) {
throw this.createBusinessError('包材ID不存在', 404);
}
return materialRow;
}
/**
* 根据包材编码查询当前仓库启用中的包材。
* @param {string} packageMaterialCode 包材编码。
* @param {number} warehouseId 仓库 ID。
* @return {Promise<Object>} 包材记录。
*/
async findActivePackageMaterialByCode(packageMaterialCode, warehouseId) {
const packageMaterialModel = this.ctx.model && this.ctx.model.PackageMaterial;
if (!packageMaterialModel || typeof packageMaterialModel.findOne !== 'function') {
throw this.createBusinessError('包材模型未初始化', 500);
}
const materialRow = await packageMaterialModel.findOne({
where: {
warehouse_id: warehouseId,
material_code: packageMaterialCode,
status: 1,
},
attributes: [ 'id', 'material_code', 'material_name', 'warehouse_id', 'status' ],
raw: true,
});
if (!materialRow) {
throw this.createBusinessError('包材编码不存在', 404);
}
return materialRow;
}
/**
* 根据订单号与运单号查询有效订单快递记录。
* @param {number} orderId 订单 ID。
* @param {string} waybillCode 运单号。
* @param {number} warehouseId 仓库 ID。
* @return {Promise<Object>} 订单快递记录。
*/
async findValidOrderExpressByOrderAndWaybill(orderId, waybillCode, warehouseId) {
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findOne !== 'function') {
throw this.createBusinessError('订单快递模型未初始化', 500);
}
const orderExpressRow = await orderExpressModel.findOne({
where: {
order_id: orderId,
waybill_code: waybillCode,
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'warehouse_id', 'delete_at', 'package_material_id' ],
raw: true,
});
if (!orderExpressRow) {
throw this.createBusinessError('订单运单记录不存在', 404);
}
return orderExpressRow;
}
/**
* 查询订单拦截状态(依次查询 current → dispatch 分表)。
* @param {number} orderId 订单 ID。
* @param {number} warehouseId 仓库 ID。
* @return {Promise<string>} 拦截状态,查询失败时返回 'none'。
*/
async findOrderInterceptStatus(orderId, warehouseId) {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
return 'none';
}
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (row) {
return String(row.intercept_status || '').trim() || 'none';
}
} catch (_err) { continue; }
}
return 'none';
}
/**
* 断言订单未进入拦截流程,否则抛出业务异常。
* @param {number} orderId 订单 ID。
* @param {number} warehouseId 仓库 ID。
* @param {string} [actionText='继续作业'] 被阻断的作业文案。
* @return {Promise<void>} 无返回值。
*/
async assertOrderNotIntercepted(orderId, warehouseId, actionText = '继续作业') {
const interceptStatus = await this.findOrderInterceptStatus(orderId, warehouseId);
if (isInterceptedOrderStatus(interceptStatus)) {
throw this.createBusinessError(`订单已被拦截,无法${actionText}`, 400);
}
}
/**
* 规范化并校验称重重量。
*
* 必须为正整数(单位 g),且必须大于 0。
*
* @param {number|string} weighingWeight 称重重量(g)。
* @return {number} 合法重量数值。
*/
normalizeWeighingWeight(weighingWeight) {
if (weighingWeight === null || weighingWeight === undefined || String(weighingWeight).trim() === '') {
throw this.createBusinessError('weighing_weight 必填', 400);
}
const normalizedWeightText = String(weighingWeight).trim();
if (!/^\d+$/.test(normalizedWeightText)) {
throw this.createBusinessError('weighing_weight 格式非法,必须为正整数(单位 g)', 400);
}
const normalizedWeight = Number(normalizedWeightText);
if (!Number.isFinite(normalizedWeight) || normalizedWeight <= 0) {
throw this.createBusinessError('weighing_weight 必须大于 0', 400);
}
return normalizedWeight;
}
/**
* 读取订单下有效快递记录。
* @param {number} orderId 订单ID。
* @param {number|string|null|undefined} warehouseId 仓库ID。
* @return {Promise<Array<Object>>} 快递记录列表。
*/
async findValidOrderExpressRows(orderId, warehouseId) {
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findAll !== 'function') {
throw this.createBusinessError('订单快递模型未初始化', 500);
}
const where = {
order_id: orderId,
delete_at: null,
};
if (warehouseId !== null && warehouseId !== undefined && warehouseId !== '') {
where.warehouse_id = warehouseId;
}
const rows = await orderExpressModel.findAll({
where,
attributes: [ 'id', 'order_id', 'waybill_code', 'weighing_weight' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
return Array.isArray(rows) ? rows : [];
}
/**
* 更新订单运单称重重量。
*
* 支持团购波次批量设置:
* - 散单(wave_id = 0)或非团购波次:仅更新单个订单的运单重量。
* - 团购波次(wave_type = 1):将同一重量批量设置到该波次下所有订单的运单上。
*
* @param {Object} payload 入参对象。
* @param {number|string} payload.orderId 订单ID。
* @param {string} [payload.waybillCode] 运单号,多运单场景必填。
* @param {number|string} payload.weighingWeight 称重重量(g)。
* @return {Promise<Object>} 单订单返回 {order_id, waybill_code, weighing_weight, items_weight};
* 团购批量返回 {wave_id, wave_no, weighing_weight, total_weight, split_count, splits, store_name, sys_logistics_name, items_weight}。
*/
async updateWeighingWeight(payload = {}) {
const requestData = payload && typeof payload === 'object' ? payload : {};
const {
orderId,
waybillCode = '',
weighingWeight,
} = requestData;
const normalizedOrderId = this.normalizeOrderId(orderId);
const normalizedWeight = this.normalizeWeighingWeight(weighingWeight);
const normalizedWaybillCode = String(waybillCode || '').trim();
const warehouseId = this.ctx && this.ctx.user ? this.ctx.user.store_id : null;
// 无法获取仓库ID时降级为单个订单逻辑
if (!warehouseId) {
return await this._updateSingleOrderWeight(
normalizedOrderId, normalizedWaybillCode, normalizedWeight, warehouseId
);
}
// 先查运单表校验运单是否存在
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findOne !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
const expressRow = await orderExpressModel.findOne({
where: {
order_id: normalizedOrderId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'business_key' ],
raw: true,
});
if (!expressRow) {
throw this.createBusinessError('运单号不存在', 404);
}
// 拦截流程中的订单不允许称重
await this.assertOrderNotIntercepted(normalizedOrderId, warehouseId, '称重');
// 依次查询多个订单表获取波次信息:current → history → dispatch
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
throw this.createBusinessError('订单模型未初始化', 500);
}
const orderTableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'history', getModel: () => orderDeliveryFactory.getHistoryModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
// 序列表定位优先:命中则先查对应分表,未命中(存量订单)按原顺序回退遍历
try {
if (orderDeliveryFactory && typeof orderDeliveryFactory.getOrderLocation === 'function') {
const preferredLocation = await orderDeliveryFactory.getOrderLocation(normalizedOrderId, warehouseId);
if (preferredLocation) {
orderTableOrders.sort((a, b) => (a.label === preferredLocation ? -1 : b.label === preferredLocation ? 1 : 0));
}
}
} catch (_err) { /* 定位失败,保持原遍历顺序 */ }
let orderRow = null;
let orderDeliveryModel = null;
for (const entry of orderTableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') {
continue;
}
const row = await model.findOne({
where: { id: normalizedOrderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
});
if (row) {
orderRow = row;
orderDeliveryModel = model;
break;
}
} catch (_err) {
// 该表可能不存在,继续尝试下一张表
continue;
}
}
// 所有表都找不到 → 兼容前端传入 wave_id 的场景,尝试按波次查询
if (!orderRow) {
const fallbackModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
return await this._tryWaveCompatibility(
normalizedOrderId, normalizedWaybillCode, normalizedWeight, warehouseId, fallbackModel
);
}
const waveId = Number(orderRow.wave_id || 0);
// 散单 → 走单个订单逻辑
if (waveId === 0) {
return await this._updateSingleOrderWeight(
normalizedOrderId, normalizedWaybillCode, normalizedWeight, warehouseId
);
}
// 查询波次类型
const waveBatchModel = this.ctx.model && this.ctx.model.WaveBatch;
if (!waveBatchModel || typeof waveBatchModel.findOne !== 'function') {
throw this.createBusinessError('波次模型未初始化', 500);
}
const waveRow = await waveBatchModel.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 波次记录缺失或非团购波次 → 降级为单个订单逻辑
if (!waveRow || Number(waveRow.wave_type) !== 1) {
return await this._updateSingleOrderWeight(
normalizedOrderId, normalizedWaybillCode, normalizedWeight, warehouseId
);
}
// 团购波次 → 批量设置同一重量
return await this._updateWaveOrderWeight(
waveId, String(waveRow.wave_no || ''), normalizedWeight, warehouseId, orderDeliveryModel, normalizedOrderId
);
}
/**
* 通过运单号更新称重重量(运单号模式,order_id=0 时使用)。
*
* 从运单号反查 wms_order_express,再定位订单和波次:
* - 散单或非团购波次:仅更新该运单的称重重量。
* - 团购波次(wave_type=1):按 wave_no + business_key 批量设置同一重量,
* 并返回含拆单汇总信息的结构。
*
* @param {Object} payload 入参对象。
* @param {string} payload.waybillCode 运单号(必填)。
* @param {number|string} payload.weighingWeight 称重重量(kg)。
* @return {Promise<Object>} 单运单返回 {order_id, waybill_code, weighing_weight, items_weight};
* 团购批量返回 {wave_id, wave_no, order_id, weighing_weight, total_weight, split_count, splits, store_name, sys_logistics_name, items_weight}。
*/
async updateWeighingWeightByWaybill(payload = {}) {
const requestData = payload && typeof payload === 'object' ? payload : {};
const { waybillCode, weighingWeight } = requestData;
const normalizedWaybillCode = this.normalizeWaybillCode(waybillCode);
const normalizedWeight = this.normalizeWeighingWeight(weighingWeight);
const warehouseId = this.getCurrentWarehouseId();
// 按运单号 + 仓库ID 查 wms_order_express
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findOne !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
const expressRow = await orderExpressModel.findOne({
where: {
waybill_code: normalizedWaybillCode,
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'business_key' ],
raw: true,
});
if (!expressRow) {
throw this.createBusinessError('运单号不存在', 404);
}
const orderId = Number(expressRow.order_id || 0);
// 拦截流程中的订单不允许称重
await this.assertOrderNotIntercepted(orderId, warehouseId, '称重');
// 依次查询多个订单表获取波次信息:current → history → dispatch
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
throw this.createBusinessError('订单模型未初始化', 500);
}
const orderTableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'history', getModel: () => orderDeliveryFactory.getHistoryModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
// 序列表定位优先:命中则先查对应分表,未命中(存量订单)按原顺序回退遍历
try {
if (orderDeliveryFactory && typeof orderDeliveryFactory.getOrderLocation === 'function') {
const preferredLocation = await orderDeliveryFactory.getOrderLocation(orderId, warehouseId);
if (preferredLocation) {
orderTableOrders.sort((a, b) => (a.label === preferredLocation ? -1 : b.label === preferredLocation ? 1 : 0));
}
}
} catch (_err) { /* 定位失败,保持原遍历顺序 */ }
let orderRow = null;
let orderDeliveryModel = null;
for (const entry of orderTableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') {
continue;
}
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
});
if (row) {
orderRow = row;
orderDeliveryModel = model;
break;
}
} catch (_err) {
// 该表可能不存在,继续尝试下一张表
continue;
}
}
if (!orderRow) {
throw this.createBusinessError('运单号对应的订单不存在', 404);
}
const waveId = Number(orderRow.wave_id || 0);
// 散单 → 走单个运单逻辑
if (waveId === 0) {
return await this._updateSingleOrderWeight(
orderId, normalizedWaybillCode, normalizedWeight, warehouseId
);
}
// 查询波次类型
const waveBatchModel = this.ctx.model && this.ctx.model.WaveBatch;
if (!waveBatchModel || typeof waveBatchModel.findOne !== 'function') {
throw this.createBusinessError('波次模型未初始化', 500);
}
const waveRow = await waveBatchModel.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 非团购波次 → 降级为单运单逻辑
if (!waveRow || Number(waveRow.wave_type) !== 1) {
return await this._updateSingleOrderWeight(
orderId, normalizedWaybillCode, normalizedWeight, warehouseId
);
}
// 团购波次 → 按 wave_id 批量设置波次下全部运单
return await this._updateWaveAllOrdersWeight(
waveId,
String(waveRow.wave_no || ''),
normalizedWeight,
warehouseId,
orderDeliveryModel,
orderId
);
}
/**
* 批量更新团购波次下所有订单运单的称重重量(内部方法,运单号模式入口)。
*
* 查询波次下全部订单,按 order_id 批量更新所有运单的 weighing_weight,
* 不区分 business_key。与 _updateWaveOrderWeight 功能等价但调用入口不同。
*
* @param {number} waveId 波次ID。
* @param {string} waveNo 波次号。
* @param {number} weight 称重重量。
* @param {number} warehouseId 仓库ID。
* @param {Object} orderDeliveryModel 订单 Sequelize 模型实例。
* @param {number} orderId 触发更新的运单对应订单ID。
* @return {Promise<{wave_id:number, wave_no:string, order_id:number, weighing_weight:number, total_weight:number, split_count:number, splits:Array<{business_key:string|null, weighing_weight:number, waybill_code:string|null}>, store_name:string, sys_logistics_name:string, items_weight:number}>}
* 团购批量更新结果,含拆单汇总信息及触发订单ID。
*/
async _updateWaveAllOrdersWeight(waveId, waveNo, weight, warehouseId, orderDeliveryModel, orderId) {
// 查询波次下所有订单
const waveOrders = await orderDeliveryModel.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (!waveOrders || waveOrders.length === 0) {
throw this.createBusinessError('波次下未找到订单', 404);
}
// 波次内拦截订单不参与批量称重
const interceptedWaveOrderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
const orderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => !isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
if (interceptedWaveOrderIds.length > 0) {
this.ctx.logger.info(
`[order_express._updateWaveAllOrdersWeight] 波次内拦截订单不参与称重: ${interceptedWaveOrderIds.join(',')}`
);
}
// 批量更新波次下全部运单的称重重量
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.update !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
const { Op } = this.app.Sequelize;
const updateWhere = {
order_id: { [Op.in]: orderIds },
delete_at: null,
};
// 先验证匹配记录是否存在,避免 MySQL 因值未变返回 affected_rows=0 导致误判
const matchingCount = await orderExpressModel.count({ where: updateWhere });
if (matchingCount === 0) {
throw this.createBusinessError('批量更新称重重量失败,波次下无有效运单记录', 500);
}
await orderExpressModel.update(
{ weighing_weight: weight },
{ where: updateWhere }
);
const successCount = matchingCount;
// 写入操作日志
await this._writeWeighActionLog({
waveId,
waveNo,
weight,
warehouseId,
successCount,
totalCount: orderIds.length,
});
// 构建拆单汇总信息(按触发订单 ID 汇总)
const summary = await this._buildWaveWeighingSummary(waveId, orderId, warehouseId, weight);
// 从订单表读取当前 items_weight(只读,不做 UPDATE)
const orderRow = await orderDeliveryModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'items_weight' ],
raw: true,
});
const itemsWeight = orderRow ? Number(orderRow.items_weight || 0) : 0;
return {
wave_id: waveId,
wave_no: waveNo,
order_id: orderId,
weighing_weight: weight,
total_weight: summary.total_weight,
split_count: summary.split_count,
splits: summary.splits,
store_name: summary.store_name,
sys_logistics_name: summary.sys_logistics_name,
items_weight: itemsWeight,
};
}
/**
* 构建团购波次称重拆单汇总信息(内部方法)。
*
* 查询指定订单下所有运单记录,按 business_key 分组汇总称重重量,
* 并获取货主名称与系统快递名称。
*
* @param {number} waveId 波次ID。
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {number} currentWeight 本次设置的称重重量。
* @return {Promise<{total_weight:number, split_count:number, splits:Array<{business_key:string|null, weighing_weight:number, waybill_code:string|null}>, store_name:string, sys_logistics_name:string}>}
* 拆单汇总信息。
*/
async _buildWaveWeighingSummary(waveId, orderId, warehouseId, currentWeight) {
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findAll !== 'function') {
return {
total_weight: currentWeight,
split_count: 0,
splits: [],
store_name: '',
sys_logistics_name: '',
};
}
// 查询指定订单下所有有效运单记录
const expressRows = await orderExpressModel.findAll({
where: {
order_id: orderId,
delete_at: null,
},
attributes: [ 'business_key', 'weighing_weight', 'waybill_code' ],
raw: true,
});
// 按 business_key 分组汇总称重重量
const splitMap = new Map();
for (const row of expressRows) {
const bk = row.business_key === null || row.business_key === undefined
? '__null__'
: String(row.business_key);
if (!splitMap.has(bk)) {
splitMap.set(bk, {
business_key: row.business_key,
weighing_weight: 0,
waybill_code: row.waybill_code || null,
});
}
const entry = splitMap.get(bk);
entry.weighing_weight = entry.weighing_weight + Number(row.weighing_weight || 0);
// 优先取非空的 waybill_code 作为该拆单的代表运单号
if (!entry.waybill_code && row.waybill_code) {
entry.waybill_code = row.waybill_code;
}
}
const splits = [ ...splitMap.values() ];
const totalWeight = splits.reduce((sum, s) => sum + s.weighing_weight, 0);
// split_count:仅统计 waybill_code 不为空的 business_key
const splitCount = splits.filter(s => s.waybill_code !== null).length;
// 获取货主名称
const storeName = await this._getStoreName([ orderId ], warehouseId);
// 获取系统快递名称
const sysLogisticsName = await this._getWaveSysLogisticsName([ orderId ], warehouseId);
return {
total_weight: totalWeight,
split_count: splitCount,
splits,
store_name: storeName,
sys_logistics_name: sysLogisticsName,
};
}
/**
* 获取波次下第一个订单的货主名称(shop_nick)。
*
* @param {number[]} orderIds 订单ID列表。
* @param {number} warehouseId 仓库ID。
* @return {Promise<string>} 货主名称(shop_nick),获取失败时返回空字符串。
*/
async _getStoreName(orderIds, warehouseId) {
try {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
return '';
}
const { Op } = this.app.Sequelize;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
shop_nick: { [Op.ne]: null },
},
attributes: [ 'shop_nick' ],
raw: true,
});
if (orderRow) return String(orderRow.shop_nick || '').trim();
} catch (_err) { continue; }
}
return '';
} catch (_err) {
return '';
}
}
/**
* 获取波次下订单的系统快递名称。
*
* 取波次下第一个有值的 sys_logistics_name。
*
* @param {number[]} orderIds 订单ID列表。
* @param {number} warehouseId 仓库ID。
* @return {Promise<string>} 系统快递名称,获取失败时返回空字符串。
*/
async _getWaveSysLogisticsName(orderIds, warehouseId) {
try {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
return '';
}
const { Op } = this.app.Sequelize;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
sys_logistics_name: { [Op.ne]: null },
},
attributes: [ 'sys_logistics_name' ],
raw: true,
});
if (orderRow) return String(orderRow.sys_logistics_name || '').trim();
} catch (_err) { continue; }
}
return '';
} catch (_err) {
return '';
}
}
/**
* 更新单个订单运单的称重重量(内部方法)。
*
* @param {number} orderId 订单ID。
* @param {string} waybillCode 运单号。
* @param {number} weight 称重重量。
* @param {number|null} warehouseId 仓库ID。
* @return {Promise<{order_id:number, waybill_code:string, weighing_weight:number, items_weight:number}>} 更新结果。
*/
async _updateSingleOrderWeight(orderId, waybillCode, weight, warehouseId) {
const rows = await this.findValidOrderExpressRows(orderId, warehouseId);
if (rows.length === 0) {
throw this.createBusinessError('未找到有效的订单运单记录', 404);
}
let targetRow = null;
if (rows.length === 1) {
targetRow = rows[0];
} else {
if (!waybillCode) {
throw this.createBusinessError('多运单订单必须传入 waybill_code', 400);
}
targetRow = rows.find(
row => String(row && row.waybill_code || '').trim() === waybillCode
) || null;
if (!targetRow) {
throw this.createBusinessError('waybill_code 未匹配到该订单下的运单记录', 404);
}
}
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
const updateResult = await orderExpressModel.update(
{ weighing_weight: weight },
{ where: { id: Number(targetRow.id) } }
);
const affectedRows = Array.isArray(updateResult)
? Number(updateResult[0] || 0)
: Number(updateResult || 0);
if (!Number.isFinite(affectedRows) || affectedRows <= 0) {
throw this.createBusinessError('更新称重重量失败', 500);
}
// 写入操作日志
await this._writeWeighActionLog({
orderId: Number(targetRow.order_id),
waybillCode: String(targetRow.waybill_code || '').trim(),
weight,
warehouseId,
});
// 从订单表读取当前 items_weight(只读,不做 UPDATE)
// 依次查 current / dispatch 两张表
let itemsWeight = 0;
if (warehouseId) {
try {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (orderDeliveryFactory && typeof orderDeliveryFactory.getCurrentModel === 'function') {
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: { id: Number(targetRow.order_id), warehouse_id: warehouseId },
attributes: [ 'items_weight' ],
raw: true,
});
if (orderRow) { itemsWeight = Number(orderRow.items_weight || 0); break; }
} catch (_err) { continue; }
}
}
} catch (_err) {
// 查询失败时静默降级为 0
}
}
return {
order_id: Number(targetRow.order_id),
waybill_code: String(targetRow.waybill_code || '').trim(),
weighing_weight: weight,
items_weight: itemsWeight,
};
}
/**
* 批量更新团购波次下所有订单运单的称重重量(内部方法)。
*
* @param {number} waveId 波次ID。
* @param {string} waveNo 波次号。
* @param {number} weight 称重重量。
* @param {number|null} warehouseId 仓库ID。
* @param {Object} orderDeliveryModel 订单 Sequelize 模型实例。
* @param {number} [orderId] 触发更新的订单ID,未传时取波次下第一个订单。
* @return {Promise<{wave_id:number, wave_no:string, weighing_weight:number, total_weight:number, split_count:number, splits:Array<{business_key:string|null, weighing_weight:number, waybill_code:string|null}>, store_name:string, sys_logistics_name:string, items_weight:number}>}
* 团购批量更新结果,含拆单汇总信息。
*/
async _updateWaveOrderWeight(waveId, waveNo, weight, warehouseId, orderDeliveryModel, orderId) {
// 查询波次下所有订单
const waveOrders = await orderDeliveryModel.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (!waveOrders || waveOrders.length === 0) {
throw this.createBusinessError('波次下未找到订单', 404);
}
// 波次内拦截订单不参与批量称重
const interceptedWaveOrderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
const orderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => !isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
if (interceptedWaveOrderIds.length > 0) {
this.ctx.logger.info(
`[order_express._updateWaveOrderWeight] 波次内拦截订单不参与称重: ${interceptedWaveOrderIds.join(',')}`
);
}
const totalCount = orderIds.length;
// 批量更新所有订单的运单称重重量
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.update !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
const { Op } = this.app.Sequelize;
const updateWhere = {
order_id: { [Op.in]: orderIds },
delete_at: null,
};
// 先验证匹配记录是否存在,避免 MySQL 因值未变返回 affected_rows=0 导致误判
const matchingCount = await orderExpressModel.count({ where: updateWhere });
if (matchingCount === 0) {
throw this.createBusinessError('批量更新称重重量失败,波次下无有效运单记录', 500);
}
await orderExpressModel.update(
{ weighing_weight: weight },
{ where: updateWhere }
);
const successCount = matchingCount;
// 写入操作日志
await this._writeWeighActionLog({
waveId,
waveNo,
weight,
warehouseId,
successCount,
totalCount,
});
// 构建拆单汇总信息(按触发订单 ID 汇总,未传时取波次下第一个订单)
const scopeOrderId = (Number.isFinite(Number(orderId)) && Number(orderId) > 0)
? Number(orderId)
: orderIds[0];
const summary = await this._buildWaveWeighingSummary(waveId, scopeOrderId, warehouseId, weight);
// 从订单表读取当前 items_weight(只读,不做 UPDATE)
const orderRow = await orderDeliveryModel.findOne({
where: { id: scopeOrderId, warehouse_id: warehouseId },
attributes: [ 'items_weight' ],
raw: true,
});
const itemsWeight = orderRow ? Number(orderRow.items_weight || 0) : 0;
return {
wave_id: waveId,
wave_no: waveNo,
weighing_weight: weight,
total_weight: summary.total_weight,
split_count: summary.split_count,
splits: summary.splits,
store_name: summary.store_name,
sys_logistics_name: summary.sys_logistics_name,
items_weight: itemsWeight,
};
}
/**
* 写入称重操作日志到 wms_wave_pick_action_log(内部方法)。
*
* @param {Object} params 日志参数。
* @param {number} [params.orderId] 订单ID(单订单称重场景)。
* @param {string} [params.waybillCode] 运单号(单订单称重场景)。
* @param {number} [params.waveId] 波次ID(团购批量称重场景)。
* @param {string} [params.waveNo] 波次号(团购批量称重场景)。
* @param {number} params.weight 称重重量。
* @param {number} params.warehouseId 仓库ID。
* @param {number} [params.successCount] 批量更新成功数。
* @param {number} [params.totalCount] 批量更新总数。
* @return {Promise<void>} 无返回值。
*/
async _writeWeighActionLog(params = {}) {
const {
orderId,
waybillCode,
waveId,
waveNo,
weight,
warehouseId,
successCount,
totalCount,
} = params;
const ctxUser = this.ctx && this.ctx.user ? this.ctx.user : {};
const operatorId = Number(ctxUser.employees_id || ctxUser.id || 0);
const operatorName = String(
ctxUser.employees_name || ctxUser.name || 'system'
).trim();
const isBatch = waveId !== undefined && waveId !== null;
const tag = isBatch ? 'weigh_batch' : 'weigh';
const requestId = `${tag}_${warehouseId}_${isBatch ? waveId : orderId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
await this.ctx.model.query(
`INSERT INTO wms_wave_pick_action_log (
task_id,
warehouse_id,
wave_id,
order_id,
sku_id,
location_id,
box_no,
cart_id,
qty_delta,
action_type,
request_id,
operator_id,
device_id,
seq_no,
snapshot
) VALUES (
:taskId,
:warehouseId,
:waveId,
:orderId,
:skuId,
:locationId,
:boxNo,
:cartId,
:qtyDelta,
:actionType,
:requestId,
:operatorId,
:deviceId,
:seqNo,
:snapshot
)`,
{
replacements: {
taskId: 0,
warehouseId: warehouseId || 0,
waveId: isBatch ? waveId : null,
orderId: isBatch ? null : (orderId || 0),
skuId: null,
locationId: null,
boxNo: null,
cartId: null,
qtyDelta: 0,
actionType: isBatch ? 'weigh_batch' : 'weigh',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify(isBatch
? {
wave_id: waveId,
wave_no: waveNo || '',
weighing_weight: weight,
success_count: successCount,
total_count: totalCount,
operator_name: operatorName,
}
: {
order_id: orderId,
waybill_code: waybillCode || '',
weighing_weight: weight,
operator_name: operatorName,
}),
},
type: this.ctx.model.QueryTypes.INSERT,
}
);
// 写入 order_operation_log
try {
const operationLogService = this.ctx
&& this.ctx.service
&& this.ctx.service.systems
&& this.ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logPayloads = [];
if (isBatch && waveId) {
logPayloads.push({
businessType: 'order',
businessId: `wave_${waveId}`,
operationCode: 'ORDER_WEIGH',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
message: `波次 ${waveNo || waveId} 批量称重 ${weight}g,成功 ${successCount}/${totalCount}`,
warehouseId,
waveId,
waveNo: waveNo || '',
weighingWeight: weight,
successCount,
totalCount,
},
});
} else if (orderId) {
logPayloads.push({
businessType: 'order',
businessId: `${orderId}`,
operationCode: 'ORDER_WEIGH',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
message: `订单称重 ${weight}g`,
warehouseId,
orderId,
waybillCode: waybillCode || '',
weighingWeight: weight,
},
});
}
if (logPayloads.length > 0) {
await operationLogService.createOperationLogs(logPayloads);
}
}
} catch (e) {
this.ctx.logger.warn('[order_express._writeWeighActionLog] 写入 operation_log 失败,不影响主流程', {
error: e && e.message,
waveId,
orderId,
});
}
}
/**
* 先用传入的 ID 在 wms_wave_batch 中查找波次:
* - 波次不存在 → 抛出"订单不存在"错误。
* - 波次存在且 wave_type = 1(团购)→ 走团购批量称重逻辑。
* - 波次存在但 wave_type ≠ 1 → 无法确定具体订单,抛出错误提示传入正确的 order_id。
*
* @param {number} waveIdLike 可能是 wave_id 的数值。
* @param {string} waybillCode 运单号(兼容参数,本路径不使用)。
* @param {number} weight 称重重量。
* @param {number|null} warehouseId 仓库ID。
* @param {Object} orderDeliveryModel 订单 Sequelize 模型实例。
* @return {Promise<Object>} 团购批量更新结果。
* @throws {Error} 波次不存在或非团购波次时抛出业务错误。
*/
async _tryWaveCompatibility(waveIdLike, waybillCode, weight, warehouseId, orderDeliveryModel) {
const waveBatchModel = this.ctx.model && this.ctx.model.WaveBatch;
if (!waveBatchModel || typeof waveBatchModel.findOne !== 'function') {
throw this.createBusinessError('订单不存在', 404);
}
const waveRow = await waveBatchModel.findOne({
where: { wave_id: waveIdLike, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 波次也不存在 → 报订单不存在
if (!waveRow) {
throw this.createBusinessError('订单不存在', 404);
}
// 非团购波次 → 无法确定具体订单,提示前端传入正确的 order_id
if (Number(waveRow.wave_type) !== 1) {
throw this.createBusinessError(
`传入的 ID ${waveIdLike} 对应波次(wave_no: ${waveRow.wave_no}),非团购波次,请传入正确的 order_id`,
400
);
}
// 团购波次 → 批量设置同一重量
return await this._updateWaveOrderWeight(
waveIdLike,
String(waveRow.wave_no || ''),
weight,
warehouseId,
orderDeliveryModel
);
}
/**
* 写入或更新商品结构-包材绑定关系记录。
*
* 若订单的 items_hash 不存在则跳过;关系表写入失败不影响主流程。
*
* @param {Object} params 绑定上下文参数。
* @param {number} params.orderId 订单ID。
* @param {string} params.waybillCode 运单号。
* @param {number} params.packageMaterialId 包材ID。
* @param {string} params.packageMaterialCode 包材编码。
* @param {string} params.packageMaterialName 包材名称。
* @param {number} params.warehouseId 仓库ID。
* @return {Promise<void>}
*/
async _upsertPackageMaterialItemRelation({ orderId, waybillCode, packageMaterialId, packageMaterialCode, packageMaterialName, warehouseId }) {
const { ctx } = this;
try {
// 1. 查订单的 items_hash / items_crc(依次查 current / dispatch 两张表)
const orderDeliveryFactory = ctx.model && ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') return;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'items_hash', 'items_crc' ],
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (!orderRow || !orderRow.items_hash) return;
const { items_hash: itemsHash, items_crc: itemsCrc } = orderRow;
// 2. 查关系表
const relationModel = ctx.model && ctx.model.PackageMaterialItemRelation;
if (!relationModel) return;
const existing = await relationModel.findOne({
where: {
warehouse_id: warehouseId,
items_hash: itemsHash,
items_crc: itemsCrc,
package_material_id: packageMaterialId,
delete_at: null,
},
raw: true,
});
// 3. 查包材完整快照
const packageMaterialModel = ctx.model && ctx.model.PackageMaterial;
const materialRow = packageMaterialModel
? await packageMaterialModel.findOne({ where: { id: packageMaterialId }, raw: true })
: null;
const snapshot = {
package_material_code: String(packageMaterialCode || '').trim(),
package_material_name: String(packageMaterialName || '').trim(),
package_material_spec: String(materialRow && materialRow.spec || '').trim(),
package_material_type: String(materialRow && materialRow.material_type || '').trim(),
length: Number(materialRow && materialRow.length || 0),
width: Number(materialRow && materialRow.width || 0),
height: Number(materialRow && materialRow.height || 0),
weight: Number(materialRow && materialRow.weight || 0),
};
const userId = ctx.user && ctx.user.id ? Number(ctx.user.id) : null;
const now = new Date();
if (existing) {
await relationModel.update({
bind_count: (Number(existing.bind_count) || 0) + 1,
last_order_id: orderId,
last_waybill_code: waybillCode,
last_bind_user_id: userId,
last_bind_at: now,
is_active: 1,
...snapshot,
}, {
where: { id: existing.id },
});
} else {
await relationModel.create({
warehouse_id: warehouseId,
items_hash: itemsHash,
items_crc: itemsCrc,
package_material_id: packageMaterialId,
bind_count: 1,
last_order_id: orderId,
last_waybill_code: waybillCode,
last_bind_user_id: userId,
last_bind_at: now,
is_active: 1,
...snapshot,
});
}
} catch (err) {
// 关系表写入失败不影响主流程
ctx && ctx.logger && ctx.logger.error(`[packageMaterialRelation] upsert failed: ${err.message}`);
}
}
/**
* 绑定订单快递记录的包材信息。
* @param {Object} payload 入参对象。
* @param {number|string} payload.orderId 订单ID。
* @param {string} payload.waybillCode 运单号。
* @param {string} payload.packageMaterialCode 包材编码。
* @return {Promise<Object>} 绑定后的结果快照。
*/
async bindExpressPackageMaterial(payload = {}) {
const requestData = payload && typeof payload === 'object' ? payload : {};
const {
orderId,
waybillCode,
packageMaterialCode,
} = requestData;
const normalizedOrderId = this.normalizeBindOrderId(orderId);
const normalizedWaybillCode = this.normalizeWaybillCode(waybillCode);
const normalizedPackageMaterialCode = this.normalizePackageMaterialCode(packageMaterialCode);
const warehouseId = this.getCurrentWarehouseId();
const materialRow = await this.findActivePackageMaterialByCode(normalizedPackageMaterialCode, warehouseId);
const orderExpressRow = await this.findValidOrderExpressByOrderAndWaybill(normalizedOrderId, normalizedWaybillCode, warehouseId);
// 拦截流程中的订单不允许绑定包材
await this.assertOrderNotIntercepted(Number(orderExpressRow.order_id), warehouseId, '绑定包材');
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
const updateResult = await orderExpressModel.update({
package_material_id: Number(materialRow.id),
package_material_name_snapshot: String(materialRow.material_name || '').trim(),
}, {
where: {
id: Number(orderExpressRow.id),
delete_at: null,
},
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
const isSameMaterial = Number(orderExpressRow.package_material_id) === Number(materialRow.id);
if (!Number.isFinite(affectedRows) || affectedRows <= 0) {
if (!isSameMaterial) {
throw this.createBusinessError('绑定包材失败', 500);
}
// 同一包材幂等:跳过 update 报错,继续走关系表
}
await this._upsertPackageMaterialItemRelation({
orderId: normalizedOrderId,
waybillCode: normalizedWaybillCode,
packageMaterialId: Number(materialRow.id),
packageMaterialCode: String(materialRow.material_code || '').trim(),
packageMaterialName: String(materialRow.material_name || '').trim(),
warehouseId,
});
return {
order_id: Number(orderExpressRow.order_id),
waybill_code: String(orderExpressRow.waybill_code || '').trim(),
package_material_id: Number(materialRow.id),
package_material_name_snapshot: String(materialRow.material_name || '').trim(),
package_material_code: String(materialRow.material_code || '').trim(),
};
}
/**
* 根据运单号绑定包材。
*
* 仅凭运单号即可绑定包材,无需传入订单ID。
* 先按运单号 + 仓库ID 查询有效运单记录,再按包材ID查询启用中的包材,
* 最后更新运单记录的包材字段。
*
* 支持团购波次自动感知:
* - 非团购订单(wave_id=0 或 wave_type≠1):仅绑定当前运单的包材,行为与旧版一致。
* - 团购波次(wave_type=1):自动将同一波次下、相同快递业务键(business_key)的
* 所有运单批量绑定相同的包材,实现一键补齐。
*
* @param {Object} [payload={}] 请求参数。
* @param {string} payload.waybillCode 运单号。
* @param {number|string} payload.packageMaterialId 包材ID。
* @return {Promise<Object>} 单条绑定返回 {order_id, waybill_code, package_material_id, package_material_name_snapshot, package_material_code};
* 团购批量绑定返回 {wave_id, wave_no, business_key, order_id, waybill_code, package_material_id, package_material_code, package_material_name_snapshot, bind_count, bound_waybills, store_name, sys_logistics_name}。
*/
async bindExpressPackageMaterialByWaybill(payload = {}) {
const requestData = payload && typeof payload === 'object' ? payload : {};
const {
waybillCode,
packageMaterialId,
} = requestData;
const normalizedWaybillCode = this.normalizeWaybillCode(waybillCode);
const normalizedPackageMaterialId = this.normalizePackageMaterialId(packageMaterialId);
const warehouseId = this.getCurrentWarehouseId();
// 按运单号 + 仓库ID 查询有效运单记录
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findOne !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
const orderExpressRow = await orderExpressModel.findOne({
where: {
waybill_code: normalizedWaybillCode,
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'warehouse_id', 'delete_at', 'package_material_id', 'business_key' ],
raw: true,
});
if (!orderExpressRow) {
throw this.createBusinessError('运单号不存在', 404);
}
// 拦截流程中的订单不允许绑定包材
await this.assertOrderNotIntercepted(Number(orderExpressRow.order_id), warehouseId, '绑定包材');
// 查询启用中的包材
const materialRow = await this.findActivePackageMaterialById(normalizedPackageMaterialId, warehouseId);
// --- 团购波次自动感知 ---
// 依次查询 current / dispatch 表获取波次信息
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (orderDeliveryFactory && typeof orderDeliveryFactory.getCurrentModel === 'function') {
try {
const orderTableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of orderTableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: Number(orderExpressRow.order_id), warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (orderRow) {
const waveId = Number(orderRow.wave_id || 0);
if (waveId > 0) {
// 查询波次类型
const waveBatchModel = this.ctx.model && this.ctx.model.WaveBatch;
if (waveBatchModel && typeof waveBatchModel.findOne === 'function') {
const waveRow = await waveBatchModel.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 团购波次(wave_type=1)→ 按业务键分类批量绑定
if (waveRow && Number(waveRow.wave_type) === 1) {
return await this._bindWavePackageMaterialByBusinessKey({
waveId,
waveNo: String(waveRow.wave_no || ''),
businessKey: orderExpressRow.business_key ?? null,
packageMaterialId: Number(materialRow.id),
packageMaterialCode: String(materialRow.material_code || '').trim(),
packageMaterialName: String(materialRow.material_name || '').trim(),
warehouseId,
triggerOrderId: Number(orderExpressRow.order_id),
triggerWaybillCode: normalizedWaybillCode,
});
}
}
}
}
} catch (_waveErr) {
// 波次查询失败时静默降级为单条绑定,保证向后兼容
this.ctx && this.ctx.logger && this.ctx.logger.warn(
`[bindExpressPackageMaterialByWaybill] 团购波次检测失败,降级为单条绑定: ${_waveErr.message}`
);
}
}
// 非团购 → 单条绑定(保持现有逻辑)
return await this._bindSingleExpressPackageMaterial({
orderExpressRow,
materialRow,
normalizedWaybillCode,
warehouseId,
});
}
/**
* 单条运单包材绑定(内部方法)。
*
* 更新单条运单记录的包材字段,并写入包材-商品结构关系表。
*
* @param {Object} params 绑定上下文参数。
* @param {Object} params.orderExpressRow 运单记录。
* @param {Object} params.materialRow 包材记录。
* @param {string} params.normalizedWaybillCode 规范化后的运单号。
* @param {number} params.warehouseId 仓库ID。
* @return {Promise<Object>} 绑定后的结果快照,包含 order_id、waybill_code、package_material_id、package_material_name_snapshot、package_material_code。
*/
async _bindSingleExpressPackageMaterial({ orderExpressRow, materialRow, normalizedWaybillCode, warehouseId }) {
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
// 更新运单记录的包材字段
const updateResult = await orderExpressModel.update({
package_material_id: Number(materialRow.id),
package_material_name_snapshot: String(materialRow.material_name || '').trim(),
}, {
where: {
id: Number(orderExpressRow.id),
delete_at: null,
},
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
const isSameMaterial = Number(orderExpressRow.package_material_id) === Number(materialRow.id);
if (!Number.isFinite(affectedRows) || affectedRows <= 0) {
if (!isSameMaterial) {
throw this.createBusinessError('绑定包材失败', 500);
}
// 同一包材幂等:跳过 update 报错,继续走关系表
}
await this._upsertPackageMaterialItemRelation({
orderId: Number(orderExpressRow.order_id),
waybillCode: normalizedWaybillCode,
packageMaterialId: Number(materialRow.id),
packageMaterialCode: String(materialRow.material_code || '').trim(),
packageMaterialName: String(materialRow.material_name || '').trim(),
warehouseId,
});
// 写入包材绑定操作日志(单条绑定)
try {
const ctxUser = this.ctx && this.ctx.user ? this.ctx.user : {};
const operatorId = Number(ctxUser.employees_id || ctxUser.id || 0);
const operatorName = String(ctxUser.employees_name || ctxUser.name || 'system').trim() || 'system';
const opLogService = this.ctx.service && this.ctx.service.systems && this.ctx.service.systems.operationLog;
if (opLogService && typeof opLogService.createOperationLogs === 'function') {
await opLogService.createOperationLogs([{
businessType: 'order',
businessId: `${Number(orderExpressRow.order_id || 0)}`,
operationCode: 'ORDER_PACKAGE_MATERIAL_BIND',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
message: `订单绑定包材 ${String(materialRow.material_name || materialRow.material_code || '').trim()}`,
warehouseId,
orderId: Number(orderExpressRow.order_id || 0),
waybillCode: normalizedWaybillCode,
packageMaterialId: Number(materialRow.id),
packageMaterialName: String(materialRow.material_name || '').trim(),
},
}]);
}
} catch (e) {
this.ctx.logger.warn('[order_express._bindSingleExpressPackageMaterial] 写入 operation_log 失败', {
error: e && e.message,
orderId: Number(orderExpressRow.order_id || 0),
});
}
return {
order_id: Number(orderExpressRow.order_id),
waybill_code: String(orderExpressRow.waybill_code || '').trim(),
package_material_id: Number(materialRow.id),
package_material_name_snapshot: String(materialRow.material_name || '').trim(),
package_material_code: String(materialRow.material_code || '').trim(),
};
}
/**
* 团购波次按快递业务键分类批量绑定包材(内部方法)。
*
* 查询波次下所有订单,再按触发运单的 business_key 筛选出同分类的运单,
* 批量更新包材字段并写入关系表。
*
* @param {Object} params 批量绑定上下文参数。
* @param {number} params.waveId 波次ID。
* @param {string} params.waveNo 波次号。
* @param {string|null} params.businessKey 快递业务键,用于分类过滤。
* @param {number} params.packageMaterialId 包材ID。
* @param {string} params.packageMaterialCode 包材编码。
* @param {string} params.packageMaterialName 包材名称。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.triggerOrderId 触发绑定的订单ID。
* @param {string} params.triggerWaybillCode 触发绑定的运单号。
* @return {Promise<Object>} 团购批量绑定结果,含 wave_id、wave_no、business_key、order_id、waybill_code、package_material_id、package_material_code、package_material_name_snapshot、bind_count、bound_waybills、store_name、sys_logistics_name。
*/
async _bindWavePackageMaterialByBusinessKey({
waveId,
waveNo,
businessKey,
packageMaterialId,
packageMaterialCode,
packageMaterialName,
warehouseId,
triggerOrderId,
triggerWaybillCode,
}) {
// 1. 查询波次下所有订单(current + dispatch 两张表)
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
throw this.createBusinessError('订单模型未初始化', 500);
}
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const orderIdSet = new Set();
const excludedInterceptedOrderIds = [];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findAll !== 'function') continue;
const rows = await model.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (Array.isArray(rows)) {
rows.forEach(r => {
const orderId = Number(r.id);
if (isInterceptedOrderStatus(r && r.intercept_status)) {
excludedInterceptedOrderIds.push(orderId);
return;
}
orderIdSet.add(orderId);
});
}
} catch (_err) { continue; }
}
if (excludedInterceptedOrderIds.length > 0) {
this.ctx.logger.info(
`[bindExpressPackageMaterialByWaybill] 波次内拦截订单不参与批量绑定: ${excludedInterceptedOrderIds.join(',')}`
);
}
if (orderIdSet.size === 0) {
throw this.createBusinessError('波次下未找到订单', 404);
}
const orderIds = Array.from(orderIdSet);
// 2. 查询这些订单下相同 business_key 的所有有效运单
const { Op } = this.app.Sequelize;
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findAll !== 'function') {
throw this.createBusinessError('运单模型未初始化', 500);
}
// business_key 为 null 时需特殊处理 Sequelize 查询
const businessKeyWhere = (businessKey === null || businessKey === undefined)
? { [Op.is]: null }
: businessKey;
const expressRows = await orderExpressModel.findAll({
where: {
order_id: { [Op.in]: orderIds },
business_key: businessKeyWhere,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'business_key', 'package_material_id' ],
raw: true,
});
if (!expressRows || expressRows.length === 0) {
// 波次下无同 business_key 运单 → 降级为仅绑定触发运单
const orderExpressRow = await orderExpressModel.findOne({
where: { waybill_code: triggerWaybillCode, warehouse_id: warehouseId, delete_at: null },
attributes: [ 'id', 'order_id', 'waybill_code', 'package_material_id' ],
raw: true,
});
if (!orderExpressRow) {
throw this.createBusinessError('运单号不存在', 404);
}
const materialRow = {
id: packageMaterialId,
material_code: packageMaterialCode,
material_name: packageMaterialName,
};
return await this._bindSingleExpressPackageMaterial({
orderExpressRow,
materialRow,
normalizedWaybillCode: triggerWaybillCode,
warehouseId,
});
}
const expressIds = expressRows.map(r => Number(r.id));
// 3. 先验证匹配记录是否存在,避免 MySQL 因值未变返回 affected_rows=0 导致误判
const matchingCount = await orderExpressModel.count({
where: { id: { [Op.in]: expressIds }, delete_at: null },
});
if (matchingCount === 0) {
throw this.createBusinessError('批量绑定包材失败,无有效运单记录', 500);
}
// 4. 批量更新包材字段
await orderExpressModel.update(
{
package_material_id: packageMaterialId,
package_material_name_snapshot: packageMaterialName,
},
{
where: { id: { [Op.in]: expressIds }, delete_at: null },
}
);
// 5. 逐条写入包材-商品结构关系表(失败不影响主流程)
for (const row of expressRows) {
await this._upsertPackageMaterialItemRelation({
orderId: Number(row.order_id),
waybillCode: String(row.waybill_code || '').trim(),
packageMaterialId,
packageMaterialCode,
packageMaterialName,
warehouseId,
});
}
// 6. 写入操作日志
await this._writePackageMaterialActionLog({
waveId,
waveNo,
businessKey,
packageMaterialCode,
packageMaterialName,
warehouseId,
bindCount: expressRows.length,
totalOrderCount: orderIds.length,
});
// 7. 获取货主名称与系统快递名称
const storeName = await this._getStoreName(orderIds, warehouseId);
const sysLogisticsName = await this._getWaveSysLogisticsName(orderIds, warehouseId);
// 8. 构建返回结构
return {
wave_id: waveId,
wave_no: waveNo,
business_key: businessKey,
order_id: triggerOrderId,
waybill_code: triggerWaybillCode,
package_material_id: packageMaterialId,
package_material_code: packageMaterialCode,
package_material_name_snapshot: packageMaterialName,
bind_count: expressRows.length,
bound_waybills: expressRows.map(r => ({
order_id: Number(r.order_id),
waybill_code: String(r.waybill_code || '').trim(),
})),
store_name: storeName,
sys_logistics_name: sysLogisticsName,
};
}
/**
* 写入包材绑定操作日志到 wms_wave_pick_action_log(内部方法)。
*
* @param {Object} params 日志参数。
* @param {number} params.waveId 波次ID。
* @param {string} params.waveNo 波次号。
* @param {string|null} params.businessKey 快递业务键。
* @param {string} params.packageMaterialCode 包材编码。
* @param {string} params.packageMaterialName 包材名称。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.bindCount 绑定运单数。
* @param {number} params.totalOrderCount 波次下订单总数。
* @return {Promise<void>} 无返回值。
*/
async _writePackageMaterialActionLog({
waveId,
waveNo,
businessKey,
packageMaterialCode,
packageMaterialName,
warehouseId,
bindCount,
totalOrderCount,
}) {
const ctxUser = this.ctx && this.ctx.user ? this.ctx.user : {};
const operatorId = Number(ctxUser.employees_id || ctxUser.id || 0);
const operatorName = String(
ctxUser.employees_name || ctxUser.name || 'system'
).trim();
const requestId = `bind_pm_${warehouseId}_${waveId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
await this.ctx.model.query(
`INSERT INTO wms_wave_pick_action_log (
task_id,
warehouse_id,
wave_id,
order_id,
sku_id,
location_id,
box_no,
cart_id,
qty_delta,
action_type,
request_id,
operator_id,
device_id,
seq_no,
snapshot
) VALUES (
:taskId,
:warehouseId,
:waveId,
:orderId,
:skuId,
:locationId,
:boxNo,
:cartId,
:qtyDelta,
:actionType,
:requestId,
:operatorId,
:deviceId,
:seqNo,
:snapshot
)`,
{
replacements: {
taskId: 0,
warehouseId: warehouseId || 0,
waveId,
orderId: null,
skuId: null,
locationId: null,
boxNo: null,
cartId: null,
qtyDelta: 0,
actionType: 'bind_package_material',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify({
wave_id: waveId,
wave_no: waveNo || '',
business_key: businessKey,
package_material_code: packageMaterialCode,
package_material_name: packageMaterialName,
bind_count: bindCount,
total_order_count: totalOrderCount,
operator_name: operatorName,
}),
},
type: this.ctx.model.QueryTypes.INSERT,
}
);
// 写入 order_operation_log
try {
const operationLogService = this.ctx
&& this.ctx.service
&& this.ctx.service.systems
&& this.ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: `wave_${waveId}`,
operationCode: 'ORDER_PACKAGE_MATERIAL_BIND',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
message: `波次 ${waveNo || waveId} 绑定包材 ${packageMaterialName || packageMaterialCode},绑定量 ${bindCount}`,
warehouseId,
waveId,
waveNo: waveNo || '',
packageMaterialCode,
packageMaterialName,
bindCount,
businessKey,
},
}]);
}
} catch (e) {
this.ctx.logger.warn('[order_express._writePackageMaterialActionLog] 写入 operation_log 失败,不影响主流程', {
error: e && e.message,
waveId,
});
}
}
}
module.exports = OrderExpressService;