liufumingren da4208707d fix: 修复自动分配快递时 warehouse_id 上下文丢失导致 FK 约束失败及平台解析异常
- express.js: createWaybillCode 优先使用传入的 warehouse_id,修复 setImmediate 后 ctx.user 丢失导致 wms_order_express.warehouse_id 外键约束失败
- delivery_order.js: asyncProcessOrderCreated 中平台/快递解析逻辑修正
- recheckOrder.js: 复核单快递分配状态判断优化
- express_platform.js: 快递平台自动同步回传链路修正
- order_async.js: 奇门异步下单上下文增强
- polo_api_client.js: PolyAPI 客户端微调
2026-08-02 22:40:58 +08:00

4730 lines
163 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 OrderBaseService = require('./base');
class RecheckOrderService extends OrderBaseService {
/**
* 初始化复核订单系统方法免登录、免权限、免日志与免鉴权配置。
* @param {Egg.Context} ctx 请求上下文。
*/
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave,queryRecheckOrderSingleList';
const _noNeedLog = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave';
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave,queryRecheckOrderSingleList';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 扫描关键词并返回以波次为单位的复核视图。
* 支持运单号、波次号、车号三种匹配模式,并根据波次拣货模式自动分派散单/团购视图。
* - 运单号/波次号命中散单波次(pick_mode=2/3/4):返回扁平化订单列表 list_type='single',
* 顶层携带波次/拣货人/策略/任务ID等汇总信息,list 为扁平订单数组
* - 运单号/波次号命中团购波次(pick_mode=1/5):自动转为团购模式,
* 返回嵌套波次结构 list_type='group',每项含波次号、波次内订单明细(含 stock 商品明细)及相关汇总信息
* - 车号匹配(团购模式 pick_mode=1/5):返回拣货任务下所有团购波次及订单,list_type='group',保持嵌套结构,
* 顶层携带 picker_id、picker_name、task_id
* - 车号匹配(散单模式 pick_mode=2/3/4):查询任务关联的所有波次,逐波次构建扫描视图后合并,
* 返回 list_type='single',按 order_id 去重,未复核订单排前,顶层携带汇总字段
* - 运单号命中但订单无波次信息时,退回单订单详情模式(list 每项含 detail/items/expresses/logs、
* items_weight、suggested_package_material)
* - 所有模式的 list[] 每项均附带 items_weight(订单商品总重量)与 suggested_package_material(推荐包材信息,无推荐时为 null)
* @param {Object} data 请求体。
* @param {string} [data.keyword] 通用扫描关键词。
* @param {string} [data.value] 通用扫描关键词别名。
* @param {string} [data.waybill_no] 运单号。
* @param {string} [data.waybillCode] 运单号别名。
* @param {string} [data.waybill_code] 运单号别名。
* @param {string} [data.wave_no] 波次号。
* @param {string} [data.waveNo] 波次号别名。
* @param {string} [data.cart_code] 车号。
* @param {string} [data.cartCode] 车号别名。
* @return {Promise<Object>} 扫描结果,包含 match_type、list_type、picker_id、picker_name、task_id(散单/团单均有)与 list 数组,
* list 每项含 items_weight、suggested_package_material。
*/
async scanOrder(data = {}) {
const warehouseId = this.getWarehouseId();
const keyword = this.resolveScanKeyword(data);
const matchedResult = await this.pickOrderMatchByKeyword(keyword);
const { orderId, matchType, cartMatchContext, waveMatchContext } = matchedResult;
// 散单处理:运单号匹配 → 查找订单所在波次 → 拉取波次全量订单
if (matchType === 'waybill') {
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const order = await orderModel.findOne({
where: this.buildOrderWhere([ orderId ], warehouseId),
attributes: [ 'id', 'wave_id', 'wave_no', 'pick_status', 'intercept_status', 'delivery_order_code' ],
raw: true,
});
if (!order) {
throw new Error('未找到对应订单');
}
const orderWaveId = Number(order.wave_id || 0);
const orderWaveNo = String(order.wave_no || '').trim();
if (orderWaveId > 0 && orderWaveNo) {
// 检查波次是否为团购模式(pick_mode=1 团购小波次 / pick_mode=5 团购大波次)
const pickMode = await this.getPickModeByWaveId(orderWaveId, warehouseId);
if (pickMode === 1 || pickMode === 5) {
const groupTaskId = await this.getTaskIdByWaveId(orderWaveId, warehouseId);
if (groupTaskId > 0) {
const [ groupWaveList, pickerInfo ] = await Promise.all([
this.buildGroupWaveList(groupTaskId, warehouseId),
this.getPickerInfoByTaskId(groupTaskId, warehouseId),
]);
return {
match_type: matchType,
list_type: 'group',
waybill_no: keyword,
wave_id: orderWaveId,
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: groupTaskId,
list: groupWaveList,
};
}
// 找不到拣货任务时退回单订单详情模式
this.assertOrderCanRecheck(order);
const detailResult = await this.detail({ id: orderId });
const fallbackOrder = detailResult.detail || {};
const fallbackPackageMap = await this.batchQueryPackageMaterialRecommendation(
[{ items_hash: fallbackOrder.items_hash, items_crc: fallbackOrder.items_crc }],
warehouseId
);
const fallbackItemHash = String(fallbackOrder.items_hash || '').trim();
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [{
...fallbackOrder,
items: Array.isArray(detailResult.items) ? detailResult.items : [],
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
suggested_package_material: fallbackItemHash
? (fallbackPackageMap.get(fallbackItemHash) || null)
: null,
}],
};
}
const scanView = await this.buildSingleWaveScanView(orderWaveId, orderWaveNo, warehouseId);
if (scanView) {
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
...scanView,
};
}
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [],
};
}
// 无波次信息时退回单订单模式
this.assertOrderCanRecheck(order);
const detailResult = await this.detail({ id: orderId });
const noWaveOrder = detailResult.detail || {};
const noWavePackageMap = await this.batchQueryPackageMaterialRecommendation(
[{ items_hash: noWaveOrder.items_hash, items_crc: noWaveOrder.items_crc }],
warehouseId
);
const noWaveItemHash = String(noWaveOrder.items_hash || '').trim();
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [{
...noWaveOrder,
items: Array.isArray(detailResult.items) ? detailResult.items : [],
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
suggested_package_material: noWaveItemHash
? (noWavePackageMap.get(noWaveItemHash) || null)
: null,
}],
};
}
// 波次号匹配 → 直接按波次号查找波次及订单(散单/团购分流)
if (matchType === 'wave') {
const waveId = Number(waveMatchContext?.wave?.wave_id || 0);
const waveNo = String(waveMatchContext?.wave?.wave_no || '').trim();
if (waveId > 0 && waveNo) {
// 检查波次是否为团购模式(pick_mode=1 团购小波次 / pick_mode=5 团购大波次)
const pickMode = await this.getPickModeByWaveId(waveId, warehouseId);
if (pickMode === 1 || pickMode === 5) {
const groupTaskId = await this.getTaskIdByWaveId(waveId, warehouseId);
if (groupTaskId > 0) {
const [ groupWaveList, pickerInfo ] = await Promise.all([
this.buildGroupWaveList(groupTaskId, warehouseId),
this.getPickerInfoByTaskId(groupTaskId, warehouseId),
]);
return {
match_type: matchType,
list_type: 'group',
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: groupTaskId,
list: groupWaveList,
};
}
throw new Error('团购波次未找到对应拣货任务,无法加载复核视图');
}
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
if (scanView) {
return {
match_type: matchType,
list_type: 'single',
...scanView,
};
}
return {
match_type: matchType,
list_type: 'single',
list: [],
};
}
throw new Error('波次信息不完整,无法加载复核视图');
}
// 车号匹配 → 查找拣货任务 → 根据 pick_mode 分流团单/散单
if (matchType === 'cart' && cartMatchContext) {
const taskId = Number(cartMatchContext?.task?.task_id || 0);
if (taskId > 0) {
const pickMode = Number(cartMatchContext?.task?.pick_mode || 0);
const { ctx } = this;
// 团购模式(pick_mode 1/5):拉取任务下所有团购波次
if (pickMode === 1 || pickMode === 5) {
const [ groupWaveList, pickerInfo ] = await Promise.all([
this.buildGroupWaveList(taskId, warehouseId),
this.getPickerInfoByTaskId(taskId, warehouseId),
]);
return {
match_type: 'cart',
list_type: 'group',
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: taskId,
list: groupWaveList,
};
}
// 散单模式(pick_mode 2/3/4):查询任务关联的波次,逐波次构建扫描视图并合并
const taskWaveRows = await ctx.model.query(
`
SELECT wave_id, wave_no
FROM wms_wave_pick_task_wave
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
ORDER BY wave_id ASC
`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
const scanViews = [];
for (const tw of taskWaves) {
const waveId = Number(tw.wave_id || 0);
const waveNo = String(tw.wave_no || '').trim();
if (waveId > 0 && waveNo) {
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
if (scanView) {
scanViews.push(scanView);
}
}
}
if (scanViews.length === 0) {
return {
match_type: 'cart',
list_type: 'single',
task_id: taskId,
pick_mode: pickMode,
list: [],
};
}
// 合并所有波次的订单列表(按 order_id 去重)
const allOrders = scanViews.flatMap(v => (Array.isArray(v.list) ? v.list : []));
const seenOrderIds = new Set();
const mergedList = [];
for (const order of allOrders) {
const oid = Number(order.order_id || 0);
if (oid > 0 && !seenOrderIds.has(oid)) {
seenOrderIds.add(oid);
mergedList.push(order);
}
}
// 排序:未复核的排前面,其次按 wave_index 从小到大
mergedList.sort((a, b) => {
const aReviewed = a.is_reviewed ? 1 : 0;
const bReviewed = b.is_reviewed ? 1 : 0;
if (aReviewed !== bReviewed) {
return aReviewed - bReviewed;
}
return (Number(a.wave_index || 0)) - (Number(b.wave_index || 0));
});
const totalOrders = mergedList.length;
const reviewedCount = mergedList.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = totalOrders - reviewedCount;
const waveType = scanViews.find(v => Number(v.wave_type || 0) > 0)?.wave_type || 0;
const pickerInfo = await this.getPickerInfoByTaskId(taskId, warehouseId);
return {
match_type: 'cart',
list_type: 'single',
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: taskId,
wave_id: 0,
wave_no: '',
wave_type: Number(waveType || 0),
pick_mode: pickMode,
strategy_id: null,
strategy_name: '',
total_orders: totalOrders,
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
list: mergedList,
};
}
throw new Error('拣货任务信息不完整,无法加载复核视图');
}
throw new Error('未找到对应订单');
}
/**
* 通过拣货任务ID刷新复核扫描视图。
* 根据任务的 pick_mode 区分散单/团单模式,返回与 scanOrder 一致的数据结构,用于前端刷新数据。
* - 散单模式(pick_mode 2/3/4):扁平化任务下所有波次的订单列表,顶层携带拣货人/任务等汇总信息
* - 团购模式(pick_mode 1/5):返回任务下所有团购波次及订单的分组列表
* @param {Object} data 请求体。
* @param {number} data.task_id 拣货任务ID。
* @return {Promise<Object>} 扫描视图,包含 match_type、list_type、picker_id、picker_name、task_id、list 等字段,
* 散单模式额外包含 pick_mode、total_orders、reviewed_count、unreviewed_count。
*/
async scanTask(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const taskId = Number(requestData.task_id || 0);
if (!Number.isFinite(taskId) || taskId <= 0) {
throw new Error('task_id 无效');
}
const warehouseId = this.getWarehouseId();
const { ctx } = this;
// 查询拣货任务信息
const taskRows = await ctx.model.query(
`
SELECT id AS task_id, pick_mode, pick_user_id, pick_user_name
FROM wms_wave_pick_task
WHERE id = :taskId
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
if (!taskRow) {
throw new Error('未找到对应拣货任务');
}
const pickMode = Number(taskRow.pick_mode || 0);
// 查询任务关联的所有波次
const taskWaveRows = await ctx.model.query(
`
SELECT wave_id, wave_no
FROM wms_wave_pick_task_wave
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
ORDER BY wave_id ASC
`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
// 团购模式(pick_mode 1 或 5):复用 buildGroupWaveList
if (pickMode === 1 || pickMode === 5) {
const [ groupWaveList, pickerInfo ] = await Promise.all([
this.buildGroupWaveList(taskId, warehouseId),
this.getPickerInfoByTaskId(taskId, warehouseId),
]);
return {
match_type: 'task',
list_type: 'group',
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: taskId,
list: groupWaveList,
};
}
// 散单模式(pick_mode 2、3、4):逐波次构建扫描视图并合并
const scanViews = [];
for (const tw of taskWaves) {
const waveId = Number(tw.wave_id || 0);
const waveNo = String(tw.wave_no || '').trim();
if (waveId > 0 && waveNo) {
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
if (scanView) {
scanViews.push(scanView);
}
}
}
if (scanViews.length === 0) {
return {
match_type: 'task',
list_type: 'single',
task_id: taskId,
pick_mode: pickMode,
list: [],
};
}
// 合并所有波次的订单列表(按 order_id 去重)
const allOrders = scanViews.flatMap(v => (Array.isArray(v.list) ? v.list : []));
const seenOrderIds = new Set();
const mergedList = [];
for (const order of allOrders) {
const oid = Number(order.order_id || 0);
if (oid > 0 && !seenOrderIds.has(oid)) {
seenOrderIds.add(oid);
mergedList.push(order);
}
}
// 排序:未复核的排前面,其次按 wave_index 从小到大
mergedList.sort((a, b) => {
const aReviewed = a.is_reviewed ? 1 : 0;
const bReviewed = b.is_reviewed ? 1 : 0;
if (aReviewed !== bReviewed) {
return aReviewed - bReviewed;
}
return (Number(a.wave_index || 0)) - (Number(b.wave_index || 0));
});
const totalOrders = mergedList.length;
const reviewedCount = mergedList.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = totalOrders - reviewedCount;
const waveType = scanViews.find(v => Number(v.wave_type || 0) > 0)?.wave_type || 0;
return {
match_type: 'task',
list_type: 'single',
picker_id: taskRow.pick_user_id != null ? Number(taskRow.pick_user_id) : null,
picker_name: String(taskRow.pick_user_name || '').trim(),
task_id: taskId,
wave_id: 0,
wave_no: '',
wave_type: Number(waveType || 0),
pick_mode: pickMode,
strategy_id: null,
strategy_name: '',
total_orders: totalOrders,
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
list: mergedList,
};
}
/**
* 构建散单模式的扁平化扫描复核视图。
* 将波次信息、拣货人、策略、任务ID等提升到顶层,订单列表扁平化。
* @param {number} waveId 波次ID。
* @param {string} waveNo 波次号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 扁平化扫描视图,包含 picker_id、picker_name、task_id、wave_id、wave_no、
* wave_type、pick_mode、strategy_id、strategy_name、total_orders、reviewed_count、unreviewed_count、
* printed_count、unprinted_count、list。
* list 中每项额外包含 items_weight(订单商品总重量)与 suggested_package_material(推荐包材信息,无推荐时为 null)。
*/
async buildSingleWaveScanView(waveId, waveNo, warehouseId) {
const baseWaveView = await this.buildSingleWaveView(waveId, waveNo, warehouseId);
if (!baseWaveView) {
return null;
}
const normalizedWaveId = Number(waveId || 0);
const orders = Array.isArray(baseWaveView.orders) ? baseWaveView.orders : [];
// 校验波次内所有订单是否都已拣货,未拣货订单不允许复核
for (const order of orders) {
this.assertOrderCanRecheck(order);
}
// 并行查询拣货人信息和策略信息
const [ pickerInfo, strategyInfo ] = await Promise.all([
this.getPickerInfoByWaveId(normalizedWaveId, warehouseId),
this.getWaveStrategyInfo(normalizedWaveId, warehouseId),
]);
// 计算复核汇总
const reviewedCount = orders.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = orders.length - reviewedCount;
// 计算打印汇总
const printedCount = orders.filter(o => o.is_printed === true).length;
const unprintedCount = orders.length - printedCount;
// 批量查询包材推荐
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(orders, warehouseId);
// 为每个订单附加 items_weight 和包材推荐
const enrichedOrders = orders.map(order => {
const itemsHash = String(order.items_hash || '').trim();
return {
...order,
items_weight: order.items_weight != null ? Number(order.items_weight) : 0,
suggested_package_material: itemsHash ? (packageMaterialMap.get(itemsHash) || null) : null,
};
});
return {
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: pickerInfo.task_id,
wave_id: baseWaveView.wave_id,
wave_no: baseWaveView.wave_no,
wave_type: baseWaveView.wave_type,
pick_mode: baseWaveView.pick_mode,
strategy_id: strategyInfo.strategy_id,
strategy_name: strategyInfo.strategy_name,
total_orders: orders.length,
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
printed_count: printedCount,
unprinted_count: unprintedCount,
list: enrichedOrders,
};
}
/**
* 构建单个波次的复核视图(散单/团单内部共用)。
* 查询波次信息、拣货模式、以及波次下全部订单列表。
* 当 waveNo 为空但 waveId 有效时,通过 waveId 反查 wms_wave_batch 补全 waveNo。
* @param {number} waveId 波次ID。
* @param {string} waveNo 波次号,可为空字符串,为空时自动反查补全。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 波次视图对象,包含 wave_id、wave_no、wave_type、pick_mode、order_count、orders;
* 当 waveId 无效或 waveNo 无法补全时返回 null。
*/
async buildSingleWaveView(waveId, waveNo, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return null;
}
// 解析 waveNo,为空时通过 waveId 反查 wms_wave_batch 补全
let normalizedWaveNo = String(waveNo || '').trim();
if (!normalizedWaveNo) {
const fallbackRows = await ctx.model.query(
`
SELECT wave_no
FROM wms_wave_batch
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const fallbackRow = Array.isArray(fallbackRows) && fallbackRows.length > 0 ? fallbackRows[0] : null;
if (!fallbackRow || !fallbackRow.wave_no) {
return null;
}
normalizedWaveNo = String(fallbackRow.wave_no).trim();
}
// 查询波次批次信息
const waveRows = await ctx.model.query(
`
SELECT
wave_id,
wave_no,
wave_type,
wave_status,
total_orders,
processed_orders,
creator,
create_time,
update_time
FROM wms_wave_batch
WHERE wave_id = :waveId
AND wave_no = :waveNo
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, waveNo: normalizedWaveNo, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
if (!waveRow) {
return null;
}
// 查询波次关联的拣货任务,获取 pick_mode
const pickMode = await this.getPickModeByWaveId(normalizedWaveId, warehouseId);
// 查询波次下所有订单
const orders = await this.getWaveOrdersBasic(normalizedWaveNo, warehouseId);
const orderCount = orders.length;
return {
wave_id: Number(waveRow.wave_id || 0),
wave_no: String(waveRow.wave_no || '').trim(),
wave_type: Number(waveRow.wave_type || 0),
wave_status: Number(waveRow.wave_status || 0),
pick_mode: pickMode,
total_orders: Number(waveRow.total_orders || 0),
processed_orders: Number(waveRow.processed_orders || 0),
creator: String(waveRow.creator || '').trim(),
create_time: waveRow.create_time || null,
update_time: waveRow.update_time || null,
order_count: orderCount,
orders,
};
}
/**
* 构建团购波次列表视图(团单模式)。
* 根据拣货任务ID查找关联的所有波次,每个波次展开为一项。
* 波次内非拦截订单的商品明细按 stock_id 合并,plan_qty 累加,直接输出 stocks 数组;
* 拦截订单单独输出 intercepted 列表。
* @param {number} taskId 拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Array<Object>>} 波次视图列表,每项包含 wave_id、wave_no、wave_type、wave_status、
* pick_mode、total_orders、processed_orders、creator、create_time、update_time、
* order_count、box_no、reviewed_count、unreviewed_count、printed_count、unprinted_count、
* stocks(非拦截订单合并后的商品明细)、
* intercepted(拦截订单列表,仅当波次中存在拦截订单时出现,每项含 wave_index、order_id、
* delivery_order_code、intercept_status 等字段)、
* items_weight(订单商品总重量,取自波次内首个正常订单)、
* suggested_package_material(推荐包材信息,无推荐时为 null)、
* first_waybill_no(波次内首个正常订单的运单号,用于包材绑定等后续操作,无正常订单时为第一个订单的运单号,均无则为空字符串)。
*/
async buildGroupWaveList(taskId, warehouseId) {
const { ctx } = this;
const normalizedTaskId = Number(taskId || 0);
if (normalizedTaskId <= 0) {
return [];
}
// 查询拣货任务信息,获取 pick_mode
const taskRows = await ctx.model.query(
`
SELECT id AS task_id, pick_mode, current_cart_code_snapshot
FROM wms_wave_pick_task
WHERE id = :taskId
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { taskId: normalizedTaskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
if (!taskRow) {
return [];
}
const pickMode = Number(taskRow.pick_mode || 0);
// 查询任务关联的所有波次
const taskWaveRows = await ctx.model.query(
`
SELECT wave_id, wave_no, box_no
FROM wms_wave_pick_task_wave
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
ORDER BY box_no ASC, wave_id ASC
`,
{
replacements: { taskId: normalizedTaskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
// 并行查询每个波次的详细信息和订单
const waveViewPromises = taskWaves.map(async tw => {
const twWaveId = Number(tw.wave_id || 0);
const twWaveNo = String(tw.wave_no || '').trim();
if (twWaveId <= 0) {
return null;
}
const waveView = await this.buildSingleWaveView(twWaveId, twWaveNo, warehouseId);
if (!waveView) {
return null;
}
// 分离拦截订单与非拦截订单
const orders = Array.isArray(waveView.orders) ? waveView.orders : [];
const interceptedOrders = [];
const normalOrders = [];
for (const order of orders) {
const interceptStatus = String(order.intercept_status || '').trim();
if (interceptStatus === 'intercepted') {
interceptedOrders.push(order);
} else {
normalOrders.push(order);
}
}
// 校验所有非拦截订单是否都已拣货/未被拦截,不允许复核
for (const order of normalOrders) {
this.assertOrderCanRecheck(order);
}
// 团购波次中所有订单商品一致,取第一个正常订单的商品明细作为样板
const sampleOrder = normalOrders.length > 0 ? normalOrders[0] : null;
const sampleStock = sampleOrder ? (Array.isArray(sampleOrder.stock) ? sampleOrder.stock : []) : [];
const stocks = sampleStock.map(item => ({
stock_id: Number(item.stock_id || 0),
item_code: String(item.item_code || '').trim(),
item_name: String(item.item_name || '').trim(),
sku_property: String(item.sku_property || '').trim(),
packing_requirements: String(item.packing_requirements || '').trim(),
barcodes: Array.isArray(item.barcodes) ? [ ...item.barcodes ] : [],
images: Array.isArray(item.images) ? [ ...item.images ] : [],
has_shared_barcode: Boolean(item.has_shared_barcode),
plan_qty: Number(item.plan_qty || 0),
store_id: item.store_id != null ? Number(item.store_id) : 0,
owner_code: String(item.owner_code || '').trim(),
store_remark: String(item.store_remark || '').trim(),
}));
// 构建拦截订单列表
const intercepted = interceptedOrders.map(order => ({
wave_index: Number(order.wave_index || 0),
order_id: Number(order.order_id || 0),
delivery_order_code: String(order.delivery_order_code || '').trim(),
intercept_status: String(order.intercept_status || '').trim(),
}));
// 计算波次内复核统计(基于非拦截订单的 recheck_status 实时聚合)
const reviewedCount = normalOrders.filter(o => String(o.recheck_status || '').trim() === 'fin').length;
const unreviewedCount = normalOrders.length - reviewedCount;
// 计算波次内打印统计(基于非拦截订单的 is_printed 字段)
const printedCount = normalOrders.filter(o => o.is_printed === true).length;
const unprintedCount = normalOrders.length - printedCount;
// 使用任务级别的 pick_mode 覆盖(团单模式下以任务为准)
const result = {
wave_id: waveView.wave_id,
wave_no: waveView.wave_no,
wave_type: waveView.wave_type,
wave_status: waveView.wave_status,
pick_mode: pickMode,
total_orders: waveView.total_orders,
processed_orders: waveView.processed_orders,
creator: waveView.creator,
create_time: waveView.create_time,
update_time: waveView.update_time,
order_count: waveView.order_count,
box_no: Number(tw.box_no || 0),
stocks,
store_id: sampleOrder ? Number(sampleOrder.store_id || 0) : 0,
store_remark: sampleOrder ? String(sampleOrder.store_remark || '').trim() : '',
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
printed_count: printedCount,
unprinted_count: unprintedCount,
};
// 仅当存在拦截订单时才追加 intercepted 字段
if (intercepted.length > 0) {
result.intercepted = intercepted;
}
// 团购波次内所有订单商品结构一致,暂存样本订单的商品指纹信息用于后续批量查询包材推荐
result._sample_hash = sampleOrder ? String(sampleOrder.items_hash || '').trim() : '';
result._sample_crc = sampleOrder ? Number(sampleOrder.items_crc || 0) : 0;
result.items_weight = sampleOrder ? Number(sampleOrder.items_weight || 0) : 0;
result.suggested_package_material = null;
// 波次内首个订单的运单号,用于包材绑定等后续操作
// 优先取首个正常订单的运单号,若无正常订单则取首个订单(含拦截)的运单号,均无则为空字符串
const firstNonIntercepted = normalOrders.length > 0 ? normalOrders[0] : null;
const firstAnyOrder = orders.length > 0 ? orders[0] : null;
const firstOrderForWaybill = firstNonIntercepted || firstAnyOrder;
result.first_waybill_no = firstOrderForWaybill
? String(firstOrderForWaybill.waybill_no || '').trim()
: '';
return result;
});
const waveViews = (await Promise.all(waveViewPromises)).filter(view => view !== null);
// 批量查询所有波次的包材推荐
if (waveViews.length > 0) {
const sampleOrdersForPackageQuery = waveViews
.filter(wv => wv._sample_hash)
.map(wv => ({ items_hash: wv._sample_hash, items_crc: wv._sample_crc }));
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(
sampleOrdersForPackageQuery,
warehouseId
);
for (const wv of waveViews) {
if (wv._sample_hash) {
wv.suggested_package_material = packageMaterialMap.get(wv._sample_hash) || null;
}
// 清理内部临时字段
delete wv._sample_hash;
delete wv._sample_crc;
}
}
return waveViews;
}
/**
* 通过波次ID查询关联的拣货模式。
* 优先查询 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 拣货模式编码,未找到返回 0。
*/
async getPickModeByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return 0;
}
// 先按 wave_id 直接查拣货任务
const taskRows = await ctx.model.query(
`
SELECT pick_mode
FROM wms_wave_pick_task
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
ORDER BY create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(taskRows) && taskRows.length > 0) {
return Number(taskRows[0].pick_mode || 0);
}
// 通过 wms_wave_pick_task_wave 关联查询
const twRows = await ctx.model.query(
`
SELECT t.pick_mode
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
ORDER BY t.create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(twRows) && twRows.length > 0) {
return Number(twRows[0].pick_mode || 0);
}
return 0;
}
/**
* 根据波次ID查询关联的拣货任务ID。
* 优先查 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联表。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 拣货任务ID,未找到返回 0。
*/
async getTaskIdByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return 0;
}
// 先按 wave_id 直接查拣货任务
const taskRows = await ctx.model.query(
`
SELECT id AS task_id
FROM wms_wave_pick_task
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
ORDER BY create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(taskRows) && taskRows.length > 0) {
return Number(taskRows[0].task_id || 0);
}
// 通过 wms_wave_pick_task_wave 关联查询
const twRows = await ctx.model.query(
`
SELECT tw.task_id
FROM wms_wave_pick_task_wave tw
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
ORDER BY tw.task_id DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(twRows) && twRows.length > 0) {
return Number(twRows[0].task_id || 0);
}
return 0;
}
/**
* 查询波次下所有订单的基本信息列表。
* 包含运单号、打印状态、复核状态、波次内序号(优先从 wms_order_wave_index 读取真实 wave_index,
* 若表无记录则降级使用 Array.map 临时序号),按未复核优先 + 波次内序号升序排序。
* @param {string} waveNo 波次号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Array<Object>>} 订单基本信息列表,每项含 order_id、delivery_order_code、
* waybill_no、pick_status、is_printed、is_reviewed、shop_nick、items_count、
* wave_index、recheck_status、wave_id、wave_no、order_type、status、
* logistics_name、store_remark、intercept_status、items_weight、items_hash、items_crc、stock 等字段。
*/
async getWaveOrdersBasic(waveNo, warehouseId) {
const normalizedWaveNo = String(waveNo || '').trim();
if (!normalizedWaveNo) {
return [];
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_no: normalizedWaveNo,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
attributes: [
'id',
'delivery_order_code',
'pre_delivery_order_code',
'pick_status',
'wave_id',
'wave_no',
'order_type',
'status',
'recheck_status',
'items_count',
'shop_nick',
'logistics_name',
'print_status',
'store_id',
'intercept_status',
'items_weight',
'items_hash',
'items_crc',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const { ctx } = this;
const orderRowsArray = Array.isArray(orderRows) ? orderRows : [];
const orderIds = orderRowsArray.map(row => Number(row.id || 0));
// 批量查询货主备注(wms_store_warehouse.store_remask)
const storeRemarkMap = new Map();
if (orderIds.length > 0 && ctx.model && ctx.model.StoreWarehouse) {
const storeIds = [
...new Set(
orderRowsArray
.map(row => Number(row.store_id || 0))
.filter(id => id > 0)
),
];
if (storeIds.length > 0) {
const swRows = await ctx.model.StoreWarehouse.findAll({
where: {
store_id: { [this.app.Sequelize.Op.in]: storeIds },
warehouse_id: warehouseId,
},
attributes: [ 'store_id', 'store_remask' ],
raw: true,
});
for (const sw of (Array.isArray(swRows) ? swRows : [])) {
const sid = Number(sw.store_id || 0);
if (sid > 0 && !storeRemarkMap.has(sid)) {
storeRemarkMap.set(sid, String(sw.store_remask || '').trim());
}
}
}
}
// 批量查询运单信息
const waybillMap = new Map();
if (orderIds.length > 0 && ctx.model && ctx.model.OrderExpress) {
const expressRows = await ctx.model.OrderExpress.findAll({
where: { order_id: orderIds, warehouse_id: warehouseId },
attributes: [ 'order_id', 'waybill_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
for (const er of (Array.isArray(expressRows) ? expressRows : [])) {
const oid = Number(er.order_id || 0);
if (oid > 0 && !waybillMap.has(oid)) {
waybillMap.set(oid, String(er.waybill_code || '').trim());
}
}
}
// 批量查询波次顺序索引(wms_order_wave_index)
const waveIndexMap = new Map();
if (orderIds.length > 0 && ctx.model && typeof ctx.model.query === 'function') {
const waveIds = [
...new Set(
orderRowsArray
.map(row => Number(row.wave_id || 0))
.filter(id => id > 0)
),
];
if (waveIds.length > 0) {
try {
const waveIndexRows = await ctx.model.query(
`
SELECT order_id, wave_index
FROM wms_order_wave_index
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
AND order_id IN (:orderIds)
`,
{
replacements: { warehouseId, waveIds, orderIds },
type: ctx.model.QueryTypes && ctx.model.QueryTypes.SELECT,
}
);
for (const wr of (Array.isArray(waveIndexRows) ? waveIndexRows : [])) {
const wrOrderId = Number(wr && wr.order_id || 0);
if (wrOrderId > 0) {
waveIndexMap.set(wrOrderId, Number(wr.wave_index || 0));
}
}
} catch (e) {
ctx.logger.warn(`[recheckOrder.getWaveOrdersBasic] 查询波次索引失败, waveNo=${normalizedWaveNo}, error=${e.message}`);
}
}
}
// 构建订单列表
const orderList = orderRowsArray.map((row, index) => {
const orderId = Number(row.id || 0);
const recheckStatus = String(row.recheck_status || '').trim();
const printStatus = String(row.print_status || '').trim();
// 运单号:从 wms_order_express 关联表查询
const waybillNo = waybillMap.has(orderId) ? (waybillMap.get(orderId) || '') : '';
return {
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || row.pre_delivery_order_code || '').trim(),
waybill_no: waybillNo,
pick_status: String(row.pick_status || '').trim(),
is_printed: printStatus === 'fin',
is_reviewed: recheckStatus === 'fin',
shop_nick: String(row.shop_nick || '').trim(),
items_count: Number(row.items_count || 0),
wave_index: waveIndexMap.has(orderId) ? waveIndexMap.get(orderId) : index,
recheck_status: recheckStatus,
wave_id: Number(row.wave_id || 0),
wave_no: String(row.wave_no || '').trim(),
order_type: String(row.order_type || '').trim(),
status: Number(row.status || 0),
logistics_name: String(row.logistics_name || '').trim(),
store_id: Number(row.store_id || 0),
store_remark: storeRemarkMap.has(Number(row.store_id || 0))
? storeRemarkMap.get(Number(row.store_id || 0))
: '',
intercept_status: String(row.intercept_status || '').trim(),
items_weight: Number(row.items_weight || 0),
items_hash: String(row.items_hash || '').trim(),
items_crc: Number(row.items_crc || 0),
};
});
// 排序:未复核的排前面,其次按波次内序号从小到大
orderList.sort((a, b) => {
const aReviewed = a.is_reviewed ? 1 : 0;
const bReviewed = b.is_reviewed ? 1 : 0;
if (aReviewed !== bReviewed) {
return aReviewed - bReviewed;
}
return a.wave_index - b.wave_index;
});
// 补充库存信息
const enrichedList = await this.enrichOrdersWithStock(orderList, warehouseId);
return enrichedList;
}
/**
* 批量查询包材推荐信息。
* 根据订单的 items_hash + items_crc 组合,从 wms_package_material_item_relation 表
* 查询最匹配的包材推荐(按 bind_count 降序取 top-1)。
* @param {Object[]} orderList 订单列表,每项需含 items_hash、items_crc 字段。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Map<string, Object|null>>} 以 items_hash 为键的包材推荐映射,
* 值为包材信息对象或 null(无推荐时)。
*/
async batchQueryPackageMaterialRecommendation(orderList, warehouseId) {
const resultMap = new Map();
if (!Array.isArray(orderList) || orderList.length === 0) {
return resultMap;
}
// 收集所有有效的 items_hash,并为每个 hash 记录对应的 items_crc
const hashCrcMap = new Map();
for (const order of orderList) {
const hash = String(order.items_hash || '').trim();
if (!hash) {
continue;
}
const crc = Number(order.items_crc || 0);
if (!hashCrcMap.has(hash)) {
hashCrcMap.set(hash, crc);
}
}
if (hashCrcMap.size === 0) {
return resultMap;
}
const uniqueHashes = [ ...hashCrcMap.keys() ];
const { ctx } = this;
if (!ctx.model || typeof ctx.model.query !== 'function') {
return resultMap;
}
// 批量查询所有匹配的包材绑定记录,按 bind_count 降序
let relationRows = [];
try {
relationRows = await ctx.model.query(
`SELECT * FROM wms_package_material_item_relation
WHERE warehouse_id = :warehouseId
AND items_hash IN (:uniqueHashes)
AND is_active = 1
AND delete_at IS NULL
ORDER BY bind_count DESC`,
{
replacements: { warehouseId, uniqueHashes },
type: ctx.model.QueryTypes.SELECT,
}
);
} catch (e) {
ctx.logger.warn(`[recheckOrder.batchQueryPackageMaterialRecommendation] 查询包材推荐失败, error=${e.message}`);
return resultMap;
}
const rows = Array.isArray(relationRows) ? relationRows : [];
// 为每个 items_hash 取第一条匹配记录(已按 bind_count DESC 排序,且 items_crc 匹配)
for (const row of rows) {
const hash = String(row.items_hash || '').trim();
if (!hash || resultMap.has(hash)) {
continue;
}
// 校验 items_crc 是否与订单一致
const expectedCrc = hashCrcMap.get(hash);
const rowCrc = Number(row.items_crc || 0);
if (expectedCrc !== undefined && expectedCrc !== rowCrc) {
continue;
}
resultMap.set(hash, {
id: row.package_material_id,
code: String(row.package_material_code || '').trim() || null,
name: String(row.package_material_name || '').trim() || null,
spec: String(row.package_material_spec || '').trim() || null,
type: String(row.package_material_type || '').trim() || null,
weight: row.weight != null ? Number(row.weight) : null,
length: row.length != null ? Number(row.length) : null,
width: row.width != null ? Number(row.width) : null,
height: row.height != null ? Number(row.height) : null,
bind_count: row.bind_count != null ? Number(row.bind_count) : null,
});
}
return resultMap;
}
/**
* 为订单列表批量补充库存信息。
* 查询每个订单的明细商品、库存数量、条码列表和图片,构建 stock 数组。
* @param {Object[]} orderList 订单基本信息列表。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object[]>} 补充了 stock 字段的订单列表。
*/
async enrichOrdersWithStock(orderList, warehouseId) {
if (!Array.isArray(orderList) || orderList.length === 0) {
return orderList;
}
const orderIds = orderList.map(o => Number(o.order_id || 0)).filter(Boolean);
if (orderIds.length === 0) {
return orderList;
}
// 1. 批量查询所有订单的商品明细
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
const allOrderItems = await orderItemsModel.findAll({
where: {
order_id: { [this.app.Sequelize.Op.in]: orderIds },
},
attributes: [ 'order_id', 'stock_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot', 'owner_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const itemsArray = Array.isArray(allOrderItems) ? allOrderItems : [];
// 2. 收集所有唯一的 stock_id
const stockIds = [ ...new Set(
itemsArray
.map(item => Number(item.stock_id))
.filter(Boolean)
) ];
// 3. 批量查询库存信息(复用 getStockDetails,含条码与图片)
const stockMap = new Map();
const barcodeMap = new Map();
const imagesByStockId = new Map();
if (stockIds.length > 0) {
const stockDetails = await this.ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{ warehouseId }
);
for (const detail of stockDetails) {
const sid = Number(detail.id);
stockMap.set(sid, detail);
// 从 getStockDetails 提取条码
if (Array.isArray(detail.barcodes) && detail.barcodes.length > 0) {
barcodeMap.set(sid, detail.barcodes.map(bc => String(bc.barcode || '').trim()).filter(Boolean));
}
// 从 getStockDetails 提取图片 URL(兼容数组/字符串格式)
const imageUrls = Array.isArray(detail.image_url)
? detail.image_url.map(u => String(u || '').trim()).filter(Boolean)
: (detail.image_url ? [ String(detail.image_url).trim() ] : []);
if (imageUrls.length > 0) {
imagesByStockId.set(sid, imageUrls);
}
}
}
// 4. 批量查询货主备注名(wms_store_warehouse.store_remask),按 store_id 映射
const storeRemarkMapByStock = new Map();
if (stockMap.size > 0 && this.ctx.model && this.ctx.model.StoreWarehouse) {
const storeIdsForRemark = [ ...new Set(
[ ...stockMap.values() ]
.map(detail => Number(detail.store_id || 0))
.filter(id => id > 0)
) ];
if (storeIdsForRemark.length > 0) {
const swRows = await this.ctx.model.StoreWarehouse.findAll({
where: {
store_id: { [this.app.Sequelize.Op.in]: storeIdsForRemark },
warehouse_id: warehouseId,
},
attributes: [ 'store_id', 'store_remask' ],
raw: true,
});
for (const sw of (Array.isArray(swRows) ? swRows : [])) {
const sid = Number(sw.store_id || 0);
if (sid > 0 && !storeRemarkMapByStock.has(sid)) {
storeRemarkMapByStock.set(sid, String(sw.store_remask || '').trim());
}
}
}
}
// 5. 检测共享条码:查询当前所有条码是否也出现在其他 stock_id 中
const sharedBarcodeSet = new Set();
if (barcodeMap.size > 0) {
const allBarcodes = [];
for (const [ , barcodes ] of barcodeMap) {
for (const bc of barcodes) {
allBarcodes.push(bc);
}
}
if (allBarcodes.length > 0 && this.ctx.model && this.ctx.model.StockBarcode) {
const sharedRows = await this.ctx.model.query(
`SELECT barcode, COUNT(DISTINCT stock_id) AS cnt
FROM wms_stock_barcodes
WHERE barcode IN (:barcodes)
AND warehouse_id = :warehouseId
GROUP BY barcode
HAVING cnt > 1`,
{
replacements: { barcodes: allBarcodes, warehouseId },
type: this.ctx.model.QueryTypes.SELECT,
}
);
for (const row of (Array.isArray(sharedRows) ? sharedRows : [])) {
sharedBarcodeSet.add(String(row.barcode || '').trim());
}
}
}
// 6. 按 order_id 分组商品明细
const itemsByOrderId = new Map();
for (const item of itemsArray) {
const oid = Number(item.order_id);
if (!itemsByOrderId.has(oid)) {
itemsByOrderId.set(oid, []);
}
itemsByOrderId.get(oid).push(item);
}
// 7. 为每个订单构建 stock 数组
return orderList.map(order => {
const oid = Number(order.order_id || 0);
const items = itemsByOrderId.get(oid) || [];
const stock = items.map(item => {
const sid = Number(item.stock_id || 0);
const stockInfo = stockMap.get(sid) || {};
const barcodes = (() => {
const arr = barcodeMap.get(sid);
if (Array.isArray(arr) && arr.length > 0) {
return arr;
}
return [ String(item.item_code || '').trim() ];
})();
const images = imagesByStockId.get(sid) || [];
const hasSharedBarcode = (() => {
const arr = barcodeMap.get(sid);
if (Array.isArray(arr) && arr.length > 0) {
return arr.some(bc => sharedBarcodeSet.has(bc));
}
return false;
})();
return {
stock_id: sid,
item_code: String(item.item_code || stockInfo.item_code || '').trim(),
item_name: String(stockInfo.item_name || item.item_name || '').trim(),
sku_property: String(stockInfo.sku_property || '').trim(),
packing_requirements: String(stockInfo.packing_requirements || '').trim(),
barcodes,
images,
has_shared_barcode: hasSharedBarcode,
plan_qty: Number(item.plan_qty || 0),
store_id: stockInfo.store_id != null ? Number(stockInfo.store_id) : 0,
owner_code: String(item.owner_code || '').trim(),
store_remark: storeRemarkMapByStock.get(stockInfo.store_id != null ? Number(stockInfo.store_id) : 0) || '',
};
});
return {
...order,
stock,
};
});
}
/**
* 通过波次ID查询关联的拣货人信息及任务ID。
* 通过 wms_wave_pick_task_wave 关联 wms_wave_pick_task 获取 pick_user_id / pick_user_name / task_id。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ picker_id: number|null, picker_name: string, task_id: number|null }>} 拣货人信息及任务ID。
*/
async getPickerInfoByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return { picker_id: null, picker_name: '', task_id: null };
}
const rows = await ctx.model.query(
`
SELECT t.pick_user_id, t.pick_user_name, t.id AS task_id
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
AND t.pick_user_id IS NOT NULL
ORDER BY t.create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const row = Array.isArray(rows) && rows.length > 0 ? rows[0] : null;
return {
picker_id: row && row.pick_user_id != null ? Number(row.pick_user_id) : null,
picker_name: String(row && row.pick_user_name || '').trim(),
task_id: row && row.task_id != null ? Number(row.task_id) : null,
};
}
/**
* 通过拣货任务ID查询拣货人信息。
* @param {number} taskId 拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ picker_id: number|null, picker_name: string }>} 拣货人信息。
*/
async getPickerInfoByTaskId(taskId, warehouseId) {
const { ctx } = this;
const normalizedTaskId = Number(taskId || 0);
if (normalizedTaskId <= 0) {
return { picker_id: null, picker_name: '' };
}
const rows = await ctx.model.query(
`
SELECT pick_user_id, pick_user_name
FROM wms_wave_pick_task
WHERE id = :taskId
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { taskId: normalizedTaskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const row = Array.isArray(rows) && rows.length > 0 ? rows[0] : null;
return {
picker_id: row && row.pick_user_id != null ? Number(row.pick_user_id) : null,
picker_name: String(row && row.pick_user_name || '').trim(),
};
}
/**
* 查询波次关联的策略信息。
* 当前 wms_wave_batch 与 wms_wave_pick_task 均未直接存储 strategy_id,
* 因此默认返回 null,后续若补充关联字段可在此扩展查询逻辑。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ strategy_id: number|null, strategy_name: string }>} 策略信息。
*/
// eslint-disable-next-line no-unused-vars
async getWaveStrategyInfo(waveId, warehouseId) {
return {
strategy_id: null,
strategy_name: '',
};
}
/**
* 兼容旧方法名,内部统一转发到 scanOrder。
* @param {Object} data 请求体。
* @return {Promise<Object>} 扫描结果。
*/
async scanWaybill(data = {}) {
return await this.scanOrder(data);
}
/**
* 确认订单已复核,并写入复核任务记录。
* 支持两种模式:传入 wave_id 时走团购波次批量复核,否则走单订单复核。
* @param {Object} data 请求体。
* @param {number|string} [data.wave_id] 波次ID,传入时触发团购波次批量复核。
* @param {number|string} [data.order_id] 订单ID。
* @param {number|string} [data.id] 订单ID别名。
* @param {number|string} [data.orderId] 订单ID别名。
* @return {Promise<Object>} 复核确认结果。
*/
async confirmRecheck(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const warehouseId = this.getWarehouseId();
// 团购波次批量复核
const { wave_id: waveId } = requestData;
if (waveId) {
return await this.confirmRecheckByWaveId(Number(waveId), warehouseId);
}
const { ctx } = this;
const orderId = this.resolveOrderId(data);
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
const order = await orderModel.findOne({
where: orderWhere,
raw: true,
});
if (!order) {
throw new Error('未找到对应订单');
}
this.assertOrderCanRecheck(order);
const expresses = await this.getOrderExpressesByOrderId(orderId);
const waybillNo = String(expresses?.[0]?.waybill_code || '').trim();
const now = new Date();
const updateValues = {
recheck_status: 'fin',
recheck_time: now,
updated_at: now,
};
const updateResult = await orderModel.update(updateValues, {
where: orderWhere,
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
if (affectedRows <= 0) {
throw new Error('未找到对应订单');
}
const operator = this.getOrderLogOperator();
const reviewNo = this.buildRecheckReviewNo(orderId, now);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const operatorNo = String(operator.id || '').trim();
const operatorName = String(operator.name || '').trim();
await ctx.model.query(
`
INSERT INTO wms_recheck_task (
review_no,
warehouse_id,
order_id,
order_no,
waybill_no,
task_status,
scan_status,
review_emp_no,
review_emp_name,
scan_emp_no,
scan_emp_name,
scan_time,
finish_time,
remark
)
VALUES (
:reviewNo,
:warehouseId,
:orderId,
:orderNo,
:waybillNo,
:taskStatus,
:scanStatus,
:reviewEmpNo,
:reviewEmpName,
:scanEmpNo,
:scanEmpName,
:scanTime,
:finishTime,
:remark
)
`,
{
replacements: {
reviewNo,
warehouseId,
orderId,
orderNo,
waybillNo,
taskStatus: 2,
scanStatus: 1,
reviewEmpNo: operatorNo,
reviewEmpName: operatorName,
scanEmpNo: operatorNo,
scanEmpName: operatorName,
scanTime: now,
finishTime: now,
remark: '系统复核完成',
},
type: ctx.model.QueryTypes.INSERT,
}
);
// 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务
await this.updateTaskOrderReviewAndTryUnbindCart(orderId, warehouseId, operator, now);
// 写入操作日志
await this._writeRecheckActionLog({
orderId,
waybillNo,
warehouseId,
operator,
now,
});
// 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成,
// 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失
await this._tryCompleteWaveIfAllOrdersRechecked(orderId, order.wave_id, warehouseId, operator, now);
return {
order_id: orderId,
waybill_no: waybillNo,
recheck_status: 'fin',
recheck_time: now,
review_no: reviewNo,
};
}
/**
* 团购波次批量复核:将波次下所有非拦截订单标记为已复核,并更新波次批次状态为复核完成。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object>} 批量复核结果,包含 wave_id、success_count、
* intercepted_count、total_count。
*/
async confirmRecheckByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId);
if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) {
throw new Error('波次ID无效');
}
// 查询波次信息,判断是否为团购波次
const waveRows = await ctx.model.query(
`SELECT wave_id, wave_no, wave_type
FROM wms_wave_batch
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
LIMIT 1`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
if (!waveRow) {
throw new Error('未找到对应波次');
}
const waveType = Number(waveRow.wave_type || 0);
const pickMode = await this.getPickModeByWaveId(normalizedWaveId, warehouseId);
const isGroupBuy = waveType === 1 || pickMode === 1;
if (!isGroupBuy) {
throw new Error('该波次不是团购波次,不允许批量复核');
}
// 查询波次下所有订单
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
},
attributes: [
'id',
'delivery_order_code',
'pre_delivery_order_code',
'intercept_status',
'pick_status',
'recheck_status',
],
raw: true,
});
const orderList = Array.isArray(orderRows) ? orderRows : [];
if (orderList.length === 0) {
throw new Error('波次下没有订单');
}
// 分离拦截订单与非拦截订单
const normalOrders = [];
const interceptedOrders = [];
for (const order of orderList) {
if (String(order.intercept_status || '').trim() === 'intercepted') {
interceptedOrders.push(order);
} else {
normalOrders.push(order);
}
}
if (normalOrders.length === 0) {
return {
wave_id: normalizedWaveId,
success_count: 0,
intercepted_count: interceptedOrders.length,
total_count: orderList.length,
};
}
// 验证所有非拦截订单允许复核
for (const order of normalOrders) {
this.assertOrderCanRecheck(order);
}
const now = new Date();
const normalOrderIds = normalOrders
.map(o => Number(o.id))
.filter(id => id > 0);
// 批量更新订单复核状态
await orderModel.update(
{
recheck_status: 'fin',
recheck_time: now,
updated_at: now,
},
{
where: this.buildOrderWhere(normalOrderIds, warehouseId),
}
);
// 批量插入复核任务记录
const operator = this.getOrderLogOperator();
const operatorNo = String(operator.id || '').trim();
const operatorName = String(operator.name || '').trim();
if (normalOrders.length > 0) {
const valuePlaceholders = [];
const replacements = {};
let idx = 0;
for (const order of normalOrders) {
const orderId = Number(order.id);
const reviewNo = this.buildRecheckReviewNo(orderId, now);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const i = idx++;
valuePlaceholders.push(
`(:reviewNo${i}, :warehouseId${i}, :orderId${i}, :orderNo${i}, :waybillNo${i}, `
+ `:taskStatus${i}, :scanStatus${i}, :reviewEmpNo${i}, :reviewEmpName${i}, `
+ `:scanEmpNo${i}, :scanEmpName${i}, :scanTime${i}, :finishTime${i}, :remark${i})`
);
replacements[`reviewNo${i}`] = reviewNo;
replacements[`warehouseId${i}`] = warehouseId;
replacements[`orderId${i}`] = orderId;
replacements[`orderNo${i}`] = orderNo;
replacements[`waybillNo${i}`] = '';
replacements[`taskStatus${i}`] = 2;
replacements[`scanStatus${i}`] = 1;
replacements[`reviewEmpNo${i}`] = operatorNo;
replacements[`reviewEmpName${i}`] = operatorName;
replacements[`scanEmpNo${i}`] = operatorNo;
replacements[`scanEmpName${i}`] = operatorName;
replacements[`scanTime${i}`] = now;
replacements[`finishTime${i}`] = now;
replacements[`remark${i}`] = '系统复核完成';
}
const insertSQL = `
INSERT INTO wms_recheck_task (
review_no,
warehouse_id,
order_id,
order_no,
waybill_no,
task_status,
scan_status,
review_emp_no,
review_emp_name,
scan_emp_no,
scan_emp_name,
scan_time,
finish_time,
remark
) VALUES ${valuePlaceholders.join(', ')}
`;
await ctx.model.query(insertSQL, {
replacements,
type: ctx.model.QueryTypes.INSERT,
});
}
// 批量更新 wms_wave_pick_task_order 复核状态,并检查解绑车任务
await this.updateTaskOrdersReviewBatch(normalOrderIds, warehouseId, operator, now);
// 更新 wms_wave_batch 波次复核状态:标记复核完成、记录操作人与复核时间
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = 5,
check_operator = :operatorName,
check_time = :now,
processed_orders = :processedCount,
update_time = :now
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId`,
{
replacements: {
waveId: normalizedWaveId,
warehouseId,
operatorName: operatorName || operatorNo,
processedCount: normalOrders.length,
now,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
// 写入操作日志
await this._writeRecheckActionLog({
waveId: normalizedWaveId,
waveNo: String(waveRow.wave_no || '').trim(),
warehouseId,
operator,
normalOrderCount: normalOrders.length,
interceptedOrderCount: interceptedOrders.length,
totalOrderCount: orderList.length,
now,
});
return {
wave_id: normalizedWaveId,
success_count: normalOrders.length,
intercepted_count: interceptedOrders.length,
total_count: orderList.length,
};
}
/**
* 写入复核操作日志到 wms_wave_pick_action_log(内部方法)。
*
* @param {Object} params 日志参数。
* @param {number} [params.orderId] 订单ID(单订单复核场景)。
* @param {string} [params.waybillNo] 运单号(单订单复核场景)。
* @param {number} [params.waveId] 波次ID(团购批量复核场景)。
* @param {string} [params.waveNo] 波次号(团购批量复核场景)。
* @param {number} params.warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
* @param {number} [params.normalOrderCount] 复核成功的订单数(批量场景)。
* @param {number} [params.interceptedOrderCount] 拦截的订单数(批量场景)。
* @param {number} [params.totalOrderCount] 总订单数(批量场景)。
* @param {Date} params.now 操作时间。
* @return {Promise<void>} 无返回值。
*/
async _writeRecheckActionLog(params = {}) {
const {
orderId,
waybillNo,
waveId,
waveNo,
warehouseId,
operator,
normalOrderCount,
interceptedOrderCount,
totalOrderCount,
now,
} = params;
const operatorId = operator && operator.id ? Number(operator.id) : 0;
const operatorName = operator && operator.name ? String(operator.name).trim() : 'system';
const isBatch = waveId !== undefined && waveId !== null;
const tag = isBatch ? 'recheck_batch' : 'recheck';
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 ? 'recheck_batch' : 'recheck',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify(isBatch
? {
wave_id: waveId,
wave_no: waveNo || '',
success_count: normalOrderCount,
intercepted_count: interceptedOrderCount,
total_count: totalOrderCount,
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}
: {
order_id: orderId,
waybill_no: waybillNo || '',
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}),
},
type: this.ctx.model.QueryTypes.INSERT,
}
);
// 双写 order_operation_log(失败不影响主流程)
try {
const ctx = this.ctx;
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (isBatch) {
// 波次复核:按波次记录一条操作日志
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const messageParts = [];
if (waveNo) {
messageParts.push(`波次 ${String(waveNo).trim()}`);
}
messageParts.push(`复核完成,正常${normalOrderCount || 0}单、拦截${interceptedOrderCount || 0}单、总计${totalOrderCount || 0}单`);
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(waveId || ''),
operationCode: 'ORDER_RECHECK_BATCH',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: messageParts.join(''),
waveId,
waveNo: waveNo || '',
normalOrderCount: normalOrderCount || 0,
interceptedOrderCount: interceptedOrderCount || 0,
totalOrderCount: totalOrderCount || 0,
},
}]);
}
} else {
// 单订单复核
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const messageParts = [];
if (waybillNo) {
messageParts.push(`运单 ${String(waybillNo).trim()} `);
}
messageParts.push('订单复核完成');
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId || ''),
operationCode: 'ORDER_RECHECK',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: messageParts.join(''),
orderId: orderId || 0,
waybillNo: waybillNo || '',
},
}]);
}
}
} catch (e) {
this.ctx.logger.warn('[recheckOrder._writeRecheckActionLog] 写入 order_operation_log 失败', {
error: e && e.message,
orderId,
waveId,
warehouseId,
});
}
}
/**
* 更新波次拣货任务订单的复核状态,若任务下所有订单均已复核完成则自动解绑车任务。
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async updateTaskOrderReviewAndTryUnbindCart(orderId, warehouseId, operator, now) {
const { ctx } = this;
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const hasReviewStatus = taskOrderColumnSet.has('review_status');
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
const hasReviewResult = taskOrderColumnSet.has('review_result');
const hasReviewTime = taskOrderColumnSet.has('review_time');
// 若 review_status 列不存在,跳过后续所有逻辑
if (!hasReviewStatus) {
return;
}
const operatorUserId = Number(operator.id) || 0;
const reviewSetClauses = [];
reviewSetClauses.push('review_status = 1');
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
reviewSetClauses.push('update_time = NOW()');
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET ${reviewSetClauses.join(',\n ')}
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: {
orderId,
warehouseId,
operatorUserId,
now,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
let resolvedTaskId = Number(
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单所属波次查找关联的拣货任务
if (resolvedTaskId <= 0) {
resolvedTaskId = await this._resolveTaskIdByWaveFallback(orderId, warehouseId);
}
if (resolvedTaskId <= 0) {
return;
}
// 检查该任务下是否所有订单都已复核完成
const allReviewed = await this._checkTaskOrdersAllReviewed(resolvedTaskId, warehouseId);
if (!allReviewed) {
return;
}
// 任务下所有订单均已复核完成,更新任务状态为复核通过,并解绑车任务(失败不影响主流程)
try {
await this.unbindCartForTask(resolvedTaskId, warehouseId, operatorUserId);
ctx.logger.info(
`[confirmRecheck] 车任务解绑成功, taskId=${resolvedTaskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[confirmRecheck] 解绑车任务失败(复核已成功), taskId=${resolvedTaskId}, orderId=${orderId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId: resolvedTaskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
/**
* 团购模式(pick_mode=1/5)回退:通过订单的波次 ID 查找关联的拣货任务 ID。
* wms_wave_pick_task_order 在团购模式下无记录,需要绕道 wave 关联表。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 任务ID,未找到返回 0。
*/
async _resolveTaskIdByWaveFallback(orderId, warehouseId) {
const { ctx } = this;
// 查订单所属 wave_id
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const order = await orderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
});
const orderWaveId = Number(order?.wave_id || 0);
if (orderWaveId <= 0) {
return 0;
}
// 通过 wave_id 查拣货任务(仅限团购模式 pick_mode=1/5)
const taskWaveRows = await ctx.model.query(
`SELECT DISTINCT t.id AS task_id, t.pick_mode
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t
ON t.id = tw.task_id AND t.warehouse_id = :warehouseId
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
AND t.pick_mode IN (1, 5)
LIMIT 1`,
{
replacements: { waveId: orderWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const fallbackTaskId = Number(
(Array.isArray(taskWaveRows) && taskWaveRows.length > 0 ? taskWaveRows[0]?.task_id : 0)
);
if (fallbackTaskId <= 0) {
return 0;
}
// 检查波次下所有订单是否均已复核完成(团购模式以订单表 recheck_status 为准)
const unreviewedInWave = await orderModel.count({
where: {
wave_id: orderWaveId,
warehouse_id: warehouseId,
recheck_status: { [ctx.app.Sequelize.Op.ne]: 'fin' },
},
});
return unreviewedInWave === 0 ? fallbackTaskId : 0;
}
/**
* 检查拣货任务下是否所有订单均已复核完成。
* - 散单模式:检查 wms_wave_pick_task_order.review_status
* - 团购模式:已由 _resolveTaskIdByWaveFallback 预先校验,此处直接返回 true
*
* @param {number} taskId 拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<boolean>} 全部已复核返回 true。
*/
async _checkTaskOrdersAllReviewed(taskId, warehouseId) {
const { ctx } = this;
// 先确认 wms_wave_pick_task_order 中是否有记录
const totalRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const totalCount = Number(
(Array.isArray(totalRows) && totalRows.length > 0 ? totalRows[0]?.cnt : 0)
);
if (totalCount > 0) {
// 散单模式:检查是否有未复核的订单
const unreviewedRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND review_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const unreviewedCount = Number(
(Array.isArray(unreviewedRows) && unreviewedRows.length > 0 ? unreviewedRows[0]?.cnt : 0)
);
return unreviewedCount === 0;
}
// 团购模式(wms_wave_pick_task_order 无记录):
// 已在 _resolveTaskIdByWaveFallback 中通过订单表的 recheck_status 校验通过
return true;
}
/**
* 批量更新波次拣货任务订单的复核状态,并按任务维度检查是否需要解绑车任务。
* 与单订单版本不同,本方法一次性更新所有相关任务订单的 review_status,
* 再按去重后的 task_id 逐任务判断是否所有订单均已复核完成。
* @param {number[]} orderIds 订单ID列表。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async updateTaskOrdersReviewBatch(orderIds, warehouseId, operator, now) {
const { ctx } = this;
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return;
}
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const hasReviewStatus = taskOrderColumnSet.has('review_status');
if (!hasReviewStatus) {
return;
}
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
const hasReviewResult = taskOrderColumnSet.has('review_result');
const hasReviewTime = taskOrderColumnSet.has('review_time');
const operatorUserId = Number(operator.id) || 0;
const reviewSetClauses = [ 'review_status = 1' ];
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
reviewSetClauses.push('update_time = NOW()');
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET ${reviewSetClauses.join(',\n ')}
WHERE order_id IN (:orderIds)
AND warehouse_id = :warehouseId`,
{
replacements: { orderIds, warehouseId, operatorUserId, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
// 查询受影响的去重 task_id
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id IN (:orderIds)
AND warehouse_id = :warehouseId`,
{
replacements: { orderIds, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
let taskIds = (Array.isArray(taskRows) ? taskRows : [])
.map(r => Number(r.task_id || 0))
.filter(id => id > 0);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单的波次 ID 查找关联的拣货任务
if (taskIds.length === 0 && orderIds.length > 0) {
const firstOrderId = orderIds[0];
const fallbackTaskId = await this._resolveTaskIdByWaveFallback(firstOrderId, warehouseId);
if (fallbackTaskId > 0) {
taskIds = [ fallbackTaskId ];
}
}
// 逐任务判断是否所有订单均已复核完成
for (const taskId of taskIds) {
const unreviewedRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND review_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const unreviewedCount = Number(
(Array.isArray(unreviewedRows) && unreviewedRows.length > 0 ? unreviewedRows[0]?.cnt : 0)
);
if (unreviewedCount > 0) {
continue;
}
// 任务下所有订单均已复核完成,解绑车任务并更新任务状态
try {
await this.unbindCartForTask(taskId, warehouseId, operatorUserId);
ctx.logger.info(
`[confirmRecheck] 批量复核-车任务解绑成功, taskId=${taskId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[confirmRecheck] 批量复核-解绑车任务失败, taskId=${taskId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
}
/**
* 解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
* @param {number} taskId 波次拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @param {number} operatorUserId 操作员用户ID。
* @return {Promise<void>} 无返回值。
*/
async unbindCartForTask(taskId, warehouseId, operatorUserId) {
const { ctx } = this;
// 停用拣货车绑定记录
await ctx.model.query(
`UPDATE wms_pick_task_cart_binding
SET is_active = 0,
unbind_user_id = :operatorUserId,
unbind_time = NOW(),
update_time = NOW()
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND is_active = 1`,
{
replacements: { taskId, warehouseId, operatorUserId },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
/**
* 从多种兼容字段中解析订单ID。
* @param {Object} data 请求体。
* @return {number} 规范化后的订单ID。
*/
resolveOrderId(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const {
order_id: orderId,
id,
orderId: orderIdAlias,
} = requestData;
const normalizedOrderId = Number(orderId || id || orderIdAlias || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw new Error('订单ID不能为空');
}
return normalizedOrderId;
}
/**
* 从多种兼容字段中解析扫描关键词。
* @param {Object} data 请求体。
* @param {string} [data.wave_no] 波次号。
* @param {string} [data.waveNo] 波次号别名。
* @return {string} 规范化后的扫描关键词。
*/
resolveScanKeyword(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const {
keyword,
value,
waybill_no: waybillNo,
waybillCode,
waybill_code: waybillCodeAlias,
wave_no: waveNo,
waveNo: waveNoAlias,
cart_code: cartCode,
cartCode: cartCodeAlias,
} = requestData;
const normalizedKeyword = String(
keyword || value || waybillNo || waybillCode || waybillCodeAlias || waveNo || waveNoAlias || cartCode || cartCodeAlias || ''
).trim();
if (!normalizedKeyword) {
throw new Error('扫描关键词不能为空');
}
return normalizedKeyword;
}
/**
* 根据扫描关键词解析订单ID。
* 匹配优先级:运单号 → 波次号 → 车号。
* @param {string} keyword 扫描关键词。
* @return {Promise<{ orderId: number, matchType: string, cartMatchContext?: Object, waveMatchContext?: Object }>} 命中结果。
*/
async pickOrderMatchByKeyword(keyword) {
const waybillOrderId = await this.pickOrderIdByWaybill(keyword);
if (Number.isFinite(waybillOrderId) && waybillOrderId > 0) {
return {
orderId: waybillOrderId,
matchType: 'waybill',
};
}
const waveMatchContext = await this.pickWaveMatchContextByWaveNo(keyword);
const waveOrderId = Number(waveMatchContext?.order_id || 0);
if (Number.isFinite(waveOrderId) && waveOrderId > 0) {
return {
orderId: waveOrderId,
matchType: 'wave',
waveMatchContext,
};
}
const cartMatchContext = await this.pickCartMatchContextByCartCode(keyword);
const cartOrderId = Number(cartMatchContext?.order_id || 0);
if (Number.isFinite(cartOrderId) && cartOrderId > 0) {
return {
orderId: cartOrderId,
matchType: 'cart',
cartMatchContext,
};
}
throw new Error('未找到对应订单');
}
/**
* 根据运单号解析唯一订单ID。
* @param {string} waybillNo 运单号。
* @return {Promise<number>} 订单ID,未命中返回 0。
*/
async pickOrderIdByWaybill(waybillNo) {
const warehouseId = this.getWarehouseId();
const orderIds = await this.findOrderIdsByExpressNumbers([ waybillNo ], warehouseId);
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return 0;
}
const normalizedOrderIds = orderIds
.map(item => Number(item))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)
.sort((a, b) => a - b);
if (normalizedOrderIds.length === 0) {
return 0;
}
return normalizedOrderIds[0];
}
/**
* 根据车号在波次拣货任务维度反查订单ID。
* 匹配字段:任务主表当前车号快照与任务订单行车号快照。
* @param {string} cartCode 车号。
* @return {Promise<number>} 订单ID,未命中返回 0。
*/
async pickOrderIdByCartCode(cartCode) {
const cartMatchContext = await this.pickCartMatchContextByCartCode(cartCode);
const orderId = Number(cartMatchContext?.order_id || 0);
return Number.isFinite(orderId) && orderId > 0 ? orderId : 0;
}
/**
* 根据波次号查询波次信息及波次下订单列表。
* @param {string} waveNo 波次号。
* @return {Promise<{order_id:number, wave:Object|null, orders:Array<Object>, matched_order_ids:Array<number>}>} 命中上下文。
*/
async pickWaveMatchContextByWaveNo(waveNo) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const normalizedWaveNo = String(waveNo || '').trim();
if (!normalizedWaveNo) {
return {
order_id: 0,
wave: null,
orders: [],
matched_order_ids: [],
};
}
// 查询波次批次信息
const waveRows = await ctx.model.query(
`
SELECT
wave_id,
wave_no,
wave_type,
wave_status,
total_orders,
processed_orders,
creator,
create_time,
update_time
FROM wms_wave_batch
WHERE wave_no = :waveNo
AND warehouse_id = :warehouseId
ORDER BY create_time DESC, wave_id DESC
LIMIT 1
`,
{
replacements: { waveNo: normalizedWaveNo, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
if (!waveRow) {
return {
order_id: 0,
wave: null,
orders: [],
matched_order_ids: [],
};
}
const wave = {
wave_id: Number(waveRow.wave_id || 0),
wave_no: String(waveRow.wave_no || '').trim(),
wave_type: Number(waveRow.wave_type || 0),
wave_status: Number(waveRow.wave_status || 0),
total_orders: Number(waveRow.total_orders || 0),
processed_orders: Number(waveRow.processed_orders || 0),
creator: String(waveRow.creator || '').trim(),
create_time: waveRow.create_time || null,
update_time: waveRow.update_time || null,
};
// 查询波次下的订单列表
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_no: normalizedWaveNo,
warehouse_id: warehouseId,
},
attributes: [
'id',
'delivery_order_code',
'pre_delivery_order_code',
'pick_status',
'wave_id',
'wave_no',
'order_type',
'status',
'recheck_status',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const orders = (Array.isArray(orderRows) ? orderRows : []).map(row => ({
order_id: Number(row.id || 0),
delivery_order_code: String(row.delivery_order_code || row.pre_delivery_order_code || '').trim(),
pick_status: String(row.pick_status || '').trim(),
wave_id: Number(row.wave_id || 0),
wave_no: String(row.wave_no || '').trim(),
order_type: String(row.order_type || '').trim(),
status: Number(row.status || 0),
recheck_status: String(row.recheck_status || '').trim(),
}));
const matchedOrderIds = [ ...new Set(orders
.map(o => Number(o.order_id))
.filter(id => Number.isInteger(id) && id > 0)) ];
const primaryOrderId = Number(matchedOrderIds[0] || 0);
return {
order_id: Number.isFinite(primaryOrderId) && primaryOrderId > 0 ? primaryOrderId : 0,
wave,
orders,
matched_order_ids: matchedOrderIds,
};
}
/**
* 根据车号读取任务上下文及任务订单行。
* @param {string} cartCode 车号。
* @return {Promise<{order_id:number, task:Object, task_orders:Array<Object>, matched_order_ids:Array<number>}>} 命中上下文。
*/
async pickCartMatchContextByCartCode(cartCode) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
/**
* 通过车号查找匹配的拣货任务行。
* 匹配优先级:
* 1. wms_pick_task_cart_binding(车任务绑定表,unbind_time IS NULL,权威数据源)
* 2. wms_wave_pick_task.current_cart_code_snapshot / wms_wave_pick_task_order.cart_code_snapshot(快照回退兜底)
* @param {string} cartCode 车号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 任务行,未找到返回 null。
*/
const findTaskByCartCode = async (cartCode, warehouseId) => {
// 第一优先级:车任务绑定表(权威活跃绑定数据源,unbind_time IS NULL 表示未解绑)
const bindingRows = await ctx.model.query(
`
SELECT
t.id AS task_id,
t.task_no,
t.pick_mode,
t.status,
t.review_status,
t.current_cart_code_snapshot
FROM wms_pick_task_cart_binding b
INNER JOIN wms_wave_pick_task t
ON t.id = b.task_id
WHERE b.cart_code_snapshot = :cartCode
AND b.warehouse_id = :warehouseId
AND b.unbind_time IS NULL
ORDER BY b.create_time DESC, b.id DESC
LIMIT 1
`,
{
replacements: { warehouseId, cartCode },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(bindingRows) && bindingRows.length > 0) {
return bindingRows[0];
}
// 第二优先级(回退兜底):任务主表 + 任务订单行快照
const snapshotRows = await ctx.model.query(
`
SELECT
t.id AS task_id,
t.task_no,
t.pick_mode,
t.status,
t.review_status,
t.current_cart_code_snapshot
FROM wms_wave_pick_task t
WHERE t.warehouse_id = :warehouseId
AND (
t.current_cart_code_snapshot = :cartCode
OR EXISTS (
SELECT 1
FROM wms_wave_pick_task_order pto
WHERE pto.task_id = t.id
AND pto.cart_code_snapshot = :cartCode
)
)
ORDER BY t.create_time DESC, t.id DESC
LIMIT 1
`,
{
replacements: { warehouseId, cartCode },
type: ctx.model.QueryTypes.SELECT,
}
);
return (Array.isArray(snapshotRows) && snapshotRows.length > 0) ? snapshotRows[0] : null;
};
const taskRow = await findTaskByCartCode(cartCode, warehouseId);
const taskId = Number(taskRow && taskRow.task_id || 0);
if (!Number.isInteger(taskId) || taskId <= 0) {
return {
order_id: 0,
task: null,
task_orders: [],
matched_order_ids: [],
};
}
const pickMode = Number(taskRow.pick_mode || 0);
// 团购模式(小波次 pick_mode=1 / 大波次 pick_mode=5):
// wms_wave_pick_task_order 表无记录,直接返回 task 信息,
// 以 task_id 作为 order_id 保证 pickOrderMatchByKeyword 的 cartMatch.order_id > 0 检查通过
if (pickMode === 1 || pickMode === 5) {
const task = {
task_id: taskId,
task_no: String(taskRow.task_no || '').trim(),
pick_mode: pickMode,
status: Number(taskRow.status || 0),
review_status: Number(taskRow.review_status || 0),
current_cart_code_snapshot: String(taskRow.current_cart_code_snapshot || '').trim(),
};
return {
order_id: taskId,
task,
task_orders: [],
matched_order_ids: [],
};
}
const pickStatusSelect = taskOrderColumnSet.has('pick_status')
? 'pto.pick_status'
: 'NULL AS pick_status';
const waveIdSelect = taskOrderColumnSet.has('wave_id')
? 'pto.wave_id'
: 'NULL AS wave_id';
const boxNoSelect = taskOrderColumnSet.has('box_no')
? 'pto.box_no'
: 'NULL AS box_no';
const cartCodeSnapshotSelect = taskOrderColumnSet.has('cart_code_snapshot')
? 'pto.cart_code_snapshot'
: 'NULL AS cart_code_snapshot';
const taskOrderWarehouseFilterSql = taskOrderColumnSet.has('warehouse_id')
? ' AND pto.warehouse_id = :warehouseId'
: '';
const taskOrderRowsRaw = await ctx.model.query(
`
SELECT
pto.id AS task_order_id,
pto.order_id,
${pickStatusSelect},
${waveIdSelect},
${boxNoSelect},
${cartCodeSnapshotSelect}
FROM wms_wave_pick_task_order pto
WHERE pto.task_id = :taskId
${taskOrderWarehouseFilterSql}
ORDER BY pto.id ASC
`,
{
replacements: {
taskId,
warehouseId,
},
type: ctx.model.QueryTypes.SELECT,
}
);
const task = {
task_id: Number(taskRow.task_id || 0),
task_no: String(taskRow.task_no || '').trim(),
pick_mode: Number(taskRow.pick_mode || 0),
status: Number(taskRow.status || 0),
review_status: Number(taskRow.review_status || 0),
current_cart_code_snapshot: String(taskRow.current_cart_code_snapshot || '').trim(),
};
const taskOrderRows = (Array.isArray(taskOrderRowsRaw) ? taskOrderRowsRaw : []).map(row => ({
task_order_id: Number(row && row.task_order_id || 0),
order_id: Number(row && row.order_id || 0),
pick_status: String(row && row.pick_status || '').trim(),
wave_id: Number(row && row.wave_id || 0),
box_no: Number(row && row.box_no || 0),
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
}));
const matchedOrderIds = [ ...new Set(taskOrderRows
.map(row => Number(row && row.order_id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
const primaryOrderId = Number(matchedOrderIds[0] || 0);
return {
order_id: Number.isFinite(primaryOrderId) && primaryOrderId > 0 ? primaryOrderId : 0,
task,
task_orders: taskOrderRows,
matched_order_ids: matchedOrderIds,
};
}
/**
* 读取数据表字段集合。
* @param {string} tableName 数据表名。
* @return {Promise<Set<string>>} 字段名集合。
*/
async getTableColumnSet(tableName) {
const { ctx } = this;
const normalizedTableName = String(tableName || '').trim();
if (!normalizedTableName) {
return new Set();
}
const escapedTableName = normalizedTableName.replace(/`/g, '``');
try {
const rows = await ctx.model.query(`SHOW COLUMNS FROM \`${escapedTableName}\``, {
type: ctx.model.QueryTypes.SELECT,
});
return new Set((Array.isArray(rows) ? rows : [])
.map(row => String(row && row.Field || '').trim())
.filter(Boolean));
} catch (error) {
ctx.logger.warn(`[recheckOrder.getTableColumnSet] 获取字段失败, table=${normalizedTableName}, error=${error.message}`);
return new Set();
}
}
/**
* 解析拣货模式名称。
* @param {number|string} pickMode 拣货模式编码。
* @return {string} 拣货模式名称。
*/
resolvePickModeName(pickMode) {
const pickModeMap = {
1: '团购小波次',
2: '散单单品单件',
3: '散单先拣后分',
4: '边拣边分',
5: '团购大波次',
};
const normalizedPickMode = Number(pickMode || 0);
return pickModeMap[normalizedPickMode] || '未知模式';
}
/**
* 构建波次号命中语义化视图。
* @param {Object} waveMatchContext 波次号命中上下文。
* @return {Promise<Object>} 语义化视图。
*/
async buildWaveMatchView(waveMatchContext = {}) {
const context = this.isPlainObject(waveMatchContext) ? waveMatchContext : {};
const wave = this.isPlainObject(context.wave) ? context.wave : {};
const orders = Array.isArray(context.orders) ? context.orders : [];
return {
wave_id: Number(wave.wave_id || 0),
wave_no: String(wave.wave_no || '').trim(),
wave_type: Number(wave.wave_type || 0),
wave_status: Number(wave.wave_status || 0),
total_orders: Number(wave.total_orders || 0),
processed_orders: Number(wave.processed_orders || 0),
creator: String(wave.creator || '').trim(),
create_time: wave.create_time || null,
update_time: wave.update_time || null,
order_count: orders.length,
orders,
};
}
/**
* 构建车号命中语义化视图。
* @param {Object} cartMatchContext 车号命中上下文。
* @return {Promise<Object>} 语义化视图。
*/
async buildCartMatchView(cartMatchContext = {}) {
const context = this.isPlainObject(cartMatchContext) ? cartMatchContext : {};
const task = this.isPlainObject(context.task) ? context.task : {};
const taskOrders = Array.isArray(context.task_orders) ? context.task_orders : [];
const pickMode = Number(task.pick_mode || 0);
const modeName = this.resolvePickModeName(pickMode);
const enrichedTaskOrders = await this.enrichTaskOrderRows(taskOrders);
const taskSummary = {
task_id: Number(task.task_id || 0),
task_no: String(task.task_no || '').trim(),
pick_mode: pickMode,
status: Number(task.status || 0),
review_status: Number(task.review_status || 0),
current_cart_code_snapshot: String(task.current_cart_code_snapshot || '').trim(),
order_count: enrichedTaskOrders.length,
};
const baseView = {
mode_code: pickMode,
mode_name: modeName,
view_type: 'orders',
task: taskSummary,
};
if ([ 1, 5 ].includes(pickMode)) {
return {
...baseView,
view_type: 'groups',
groups: this.groupTaskOrdersByWaveId(enrichedTaskOrders),
};
}
if (pickMode === 2) {
return {
...baseView,
view_type: 'orders',
orders: enrichedTaskOrders,
};
}
if (pickMode === 3) {
return {
...baseView,
view_type: 'pick_groups',
pick_groups: this.groupTaskOrdersByPickStatus(enrichedTaskOrders),
};
}
if (pickMode === 4) {
return {
...baseView,
view_type: 'box_groups',
box_groups: this.groupTaskOrdersByBoxNo(enrichedTaskOrders),
};
}
return {
...baseView,
view_type: 'orders',
orders: enrichedTaskOrders,
};
}
/**
* 将车号匹配视图中的订单平铺为一维数组。
* 根据 view_type 从 groups / pick_groups / box_groups / orders 中提取所有订单。
* @param {Object} cartMatchView 车号匹配视图。
* @return {Array<Object>} 平铺后的订单列表。
*/
flattenCartMatchOrders(cartMatchView = {}) {
const view = this.isPlainObject(cartMatchView) ? cartMatchView : {};
const { view_type: viewType } = view;
if (viewType === 'groups') {
const groups = Array.isArray(view.groups) ? view.groups : [];
return groups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
if (viewType === 'pick_groups') {
const pickGroups = Array.isArray(view.pick_groups) ? view.pick_groups : [];
return pickGroups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
if (viewType === 'box_groups') {
const boxGroups = Array.isArray(view.box_groups) ? view.box_groups : [];
return boxGroups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
// view_type === 'orders' 或兜底
return Array.isArray(view.orders) ? view.orders : [];
}
/**
* 追加任务订单行的订单维度字段。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Promise<Array<Object>>} 扩展后的任务订单行。
*/
async enrichTaskOrderRows(taskOrders = []) {
const warehouseId = this.getWarehouseId();
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
const orderIds = [ ...new Set(normalizedTaskOrders
.map(row => Number(row && row.order_id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
if (orderIds.length === 0) {
return [];
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: this.buildOrderWhere(orderIds, warehouseId),
attributes: [ 'id', 'wave_id', 'pick_status' ],
raw: true,
});
const orderMap = new Map((Array.isArray(orderRows) ? orderRows : [])
.map(row => [
Number(row && row.id || 0),
{
wave_id: Number(row && row.wave_id || 0),
pick_status: String(row && row.pick_status || '').trim(),
},
])
.filter(item => Number(item[0]) > 0));
return normalizedTaskOrders.map(row => {
const orderId = Number(row && row.order_id || 0);
const orderInfo = orderMap.get(orderId) || {};
const waveId = Number(row && row.wave_id || 0) > 0
? Number(row && row.wave_id || 0)
: Number(orderInfo.wave_id || 0);
const pickStatus = String(row && row.pick_status || '').trim() || String(orderInfo.pick_status || '').trim() || 'unknown';
return {
task_order_id: Number(row && row.task_order_id || 0),
order_id: orderId,
wave_id: Number.isInteger(waveId) && waveId > 0 ? waveId : 0,
pick_status: pickStatus,
box_no: Number(row && row.box_no || 0),
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
};
});
}
/**
* 按 wave_id 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} wave 分组结果。
*/
groupTaskOrdersByWaveId(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `wave_${Number(row && row.wave_id || 0)}`, row => ({
wave_id: Number(row && row.wave_id || 0),
orders: [],
}));
}
/**
* 按 pick_status 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} pick_status 分组结果。
*/
groupTaskOrdersByPickStatus(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `pick_status_${String(row && row.pick_status || 'unknown').trim() || 'unknown'}`, row => ({
pick_status: String(row && row.pick_status || 'unknown').trim() || 'unknown',
orders: [],
}));
}
/**
* 按 box_no 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} box_no 分组结果。
*/
groupTaskOrdersByBoxNo(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `box_${Number(row && row.box_no || 0)}`, row => ({
box_no: Number(row && row.box_no || 0),
orders: [],
}));
}
/**
* 通用任务订单分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @param {Function} keyGetter 分组键生成器。
* @param {Function} initGroup 分组初始化函数。
* @return {Array<Object>} 分组列表。
*/
groupTaskOrders(taskOrders = [], keyGetter, initGroup) {
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
const groupMap = new Map();
normalizedTaskOrders.forEach(row => {
const groupKey = String(keyGetter(row));
if (!groupMap.has(groupKey)) {
groupMap.set(groupKey, initGroup(row));
}
const group = groupMap.get(groupKey);
group.orders.push({ ...row });
});
return Array.from(groupMap.values()).map(group => ({
...group,
order_count: Array.isArray(group.orders) ? group.orders.length : 0,
}));
}
/**
* 生成复核单号。
* @param {number} orderId 订单ID。
* @param {Date} now 当前时间。
* @return {string} 复核单号。
*/
buildRecheckReviewNo(orderId, now = new Date()) {
const timestamp = Number(now.getTime());
const paddedOrderId = String(orderId).padStart(6, '0');
return `RC${timestamp}${paddedOrderId}`;
}
/**
* 校验订单是否允许复核,未拣货订单或已拦截订单不允许复核。
* @param {Object} order 订单信息。
*/
assertOrderCanRecheck(order = {}) {
if (String(order.pick_status || '') === 'none') {
throw new Error('订单未拣货,不允许复核。');
}
const interceptStatus = String(order.intercept_status || '').trim();
if (interceptStatus === 'intercepted' || interceptStatus === 'intercepted_at_warehouse') {
throw new Error('订单已被拦截,无法提交复核');
}
}
/**
* 复核订单列表查询,通过入参 list_type 区分散单模式与团购模式。
* - 散单模式(single):返回待复核订单列表,每项为一个订单。
* - 团购模式(group):返回波次维度的复核列表,每项为一个波次及其订单汇总。
* 统一使用 list 字段名输出。
* @param {Object} data 请求参数。
* @param {string} [data.list_type='single'] 列表模式:single(散单模式)/ group(团购模式)。
* @param {Object} [data.where] 筛选条件。
* @param {Object} [data.pagination] 分页参数,兼容 page/pageSize。
* @return {Promise<Object>} 列表结果,包含 list 与 pagination。
*/
async recheckOrderList(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const { list_type: listType = 'single' } = requestData;
const normalizedListType = String(listType || 'single').trim();
if (normalizedListType === 'group') {
return await this.queryRecheckOrderGroupList(requestData);
}
return await this.queryRecheckOrderSingleList(requestData);
}
/**
* 散单模式复核列表:按订单维度返回待复核订单,支持分页与关键词/波次号/复核状态筛选。
* @param {Object} data 请求参数。
* @param {Object} [data.where] 筛选条件,支持 keyword / wave_no / recheck_status / pick_status 等。
* @param {Object} [data.pagination] 分页参数。
* @return {Promise<Object>} { list: Array<Object>, pagination: Object }。
*/
async queryRecheckOrderSingleList(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const requestData = this.isPlainObject(data) ? data : {};
const { page, pageSize } = this.normalizePagination(requestData.pagination || requestData);
const where = this.isPlainObject(requestData.where) ? requestData.where : {};
const offset = (page - 1) * pageSize;
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderTableName = this.resolveModelTableName(orderModel);
const conditions = [];
const replacements = { warehouseId, limit: pageSize, offset };
conditions.push('o.warehouse_id = :warehouseId');
conditions.push('o.pick_status != \'none\'');
conditions.push('o.recheck_status != \'fin\'');
// 关键词搜索:运单号 / 订单号
const keyword = String(where.keyword || '').trim();
if (keyword) {
conditions.push(`(
o.delivery_order_code LIKE :keyword
OR o.pre_delivery_order_code LIKE :keyword
OR EXISTS (
SELECT 1 FROM order_express oe
WHERE oe.order_id = o.id
AND oe.waybill_code LIKE :keyword
AND oe.delete_at IS NULL
)
)`);
replacements.keyword = `%${keyword}%`;
}
// 波次号筛选
const waveNo = String(where.wave_no || '').trim();
if (waveNo) {
conditions.push('o.wave_no = :waveNo');
replacements.waveNo = waveNo;
}
// 复核状态筛选
const recheckStatus = String(where.recheck_status || '').trim();
if (recheckStatus) {
conditions.push('o.recheck_status = :recheckStatus');
replacements.recheckStatus = recheckStatus;
}
// 拣货状态筛选
const pickStatus = String(where.pick_status || '').trim();
if (pickStatus) {
conditions.push('o.pick_status = :pickStatus');
replacements.pickStatus = pickStatus;
}
const whereClause = conditions.length > 0
? `WHERE ${conditions.join('\n AND ')}`
: '';
const listSql = `
SELECT
o.id AS order_id,
o.delivery_order_code,
o.pre_delivery_order_code,
o.order_type,
o.wave_id,
o.wave_no,
o.pick_status,
o.recheck_status,
o.shop_nick,
o.logistics_name,
o.items_count,
o.items_total,
o.items_weight,
o.weight_type,
o.status,
o.create_at,
o.recheck_time,
(SELECT oe.waybill_code FROM order_express oe WHERE oe.order_id = o.id AND oe.delete_at IS NULL LIMIT 1) AS waybill_code
FROM ${orderTableName} o
${whereClause}
ORDER BY o.id ASC
LIMIT :limit OFFSET :offset
`;
const countSql = `
SELECT COUNT(1) AS total
FROM ${orderTableName} o
${whereClause}
`;
const [ listRows, countRows ] = await Promise.all([
ctx.model.query(listSql, {
replacements,
type: ctx.model.QueryTypes.SELECT,
}),
ctx.model.query(countSql, {
replacements,
type: ctx.model.QueryTypes.SELECT,
}),
]);
const total = Number(
(Array.isArray(countRows) && countRows.length > 0 ? countRows[0]?.total : 0)
);
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
const list = (Array.isArray(listRows) ? listRows : []).map(row => ({
order_id: Number(row?.order_id || 0),
delivery_order_code: String(row?.delivery_order_code || row?.pre_delivery_order_code || '').trim(),
order_type: String(row?.order_type || '').trim(),
wave_id: Number(row?.wave_id || 0),
wave_no: String(row?.wave_no || '').trim(),
pick_status: String(row?.pick_status || '').trim(),
recheck_status: String(row?.recheck_status || '').trim(),
shop_nick: String(row?.shop_nick || '').trim(),
logistics_name: String(row?.logistics_name || '').trim(),
items_count: Number(row?.items_count || 0),
items_total: Number(row?.items_total || 0),
items_weight: row?.items_weight != null ? Number(row.items_weight) : null,
weight_type: this.formatWeightTypeLabel(row?.weight_type),
waybill_code: String(row?.waybill_code || '').trim(),
status: Number(row?.status || 0),
create_at: row?.create_at || null,
recheck_time: row?.recheck_time || null,
}));
return this.success('ok', {
list,
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
/**
* 团购模式复核列表:按波次维度返回复核汇总,每项包含波次信息及订单复核统计。
* @param {Object} data 请求参数。
* @param {Object} [data.where] 筛选条件,支持 wave_no / wave_type / wave_status 等。
* @param {Object} [data.pagination] 分页参数。
* @return {Promise<Object>} { list: Array<Object>, pagination: Object }。
*/
async queryRecheckOrderGroupList(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const requestData = this.isPlainObject(data) ? data : {};
const { page, pageSize } = this.normalizePagination(requestData.pagination || requestData);
const where = this.isPlainObject(requestData.where) ? requestData.where : {};
const offset = (page - 1) * pageSize;
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderTableName = this.resolveModelTableName(orderModel);
const conditions = [];
const replacements = { warehouseId, limit: pageSize, offset };
conditions.push('wb.warehouse_id = :warehouseId');
// 波次号筛选
const waveNo = String(where.wave_no || '').trim();
if (waveNo) {
conditions.push('wb.wave_no LIKE :waveNo');
replacements.waveNo = `%${waveNo}%`;
}
// 波次类型筛选
const waveType = Number(where.wave_type);
if (Number.isInteger(waveType) && waveType > 0) {
conditions.push('wb.wave_type = :waveType');
replacements.waveType = waveType;
}
// 波次状态筛选
const waveStatus = Number(where.wave_status);
if (Number.isInteger(waveStatus)) {
conditions.push('wb.wave_status = :waveStatus');
replacements.waveStatus = waveStatus;
}
const whereClause = conditions.length > 0
? `WHERE ${conditions.join('\n AND ')}`
: '';
const listSql = `
SELECT
wb.wave_id,
wb.wave_no,
wb.wave_type,
wb.wave_status,
wb.total_orders,
wb.processed_orders,
wb.creator,
wb.create_time,
wb.update_time,
COUNT(o.id) AS order_count,
SUM(CASE WHEN o.recheck_status = 'fin' THEN 1 ELSE 0 END) AS reviewed_count,
SUM(CASE WHEN o.recheck_status != 'fin' OR o.recheck_status IS NULL THEN 1 ELSE 0 END) AS unreviewed_count
FROM wms_wave_batch wb
LEFT JOIN ${orderTableName} o
ON o.wave_no = wb.wave_no
AND o.warehouse_id = wb.warehouse_id
AND o.pick_status != 'none'
${whereClause}
GROUP BY wb.wave_id, wb.wave_no, wb.wave_type, wb.wave_status,
wb.total_orders, wb.processed_orders, wb.creator,
wb.create_time, wb.update_time
ORDER BY wb.create_time DESC, wb.wave_id DESC
LIMIT :limit OFFSET :offset
`;
const countSql = `
SELECT COUNT(1) AS total
FROM wms_wave_batch wb
${whereClause}
`;
const [ listRows, countRows ] = await Promise.all([
ctx.model.query(listSql, {
replacements,
type: ctx.model.QueryTypes.SELECT,
}),
ctx.model.query(countSql, {
replacements,
type: ctx.model.QueryTypes.SELECT,
}),
]);
const total = Number(
(Array.isArray(countRows) && countRows.length > 0 ? countRows[0]?.total : 0)
);
const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
const list = (Array.isArray(listRows) ? listRows : []).map(row => {
const orderCount = Number(row?.order_count || 0);
const reviewedCount = Number(row?.reviewed_count || 0);
const unreviewedCount = Number(row?.unreviewed_count || 0);
return {
wave_id: Number(row?.wave_id || 0),
wave_no: String(row?.wave_no || '').trim(),
wave_type: Number(row?.wave_type || 0),
wave_status: Number(row?.wave_status || 0),
total_orders: Number(row?.total_orders || 0),
processed_orders: Number(row?.processed_orders || 0),
creator: String(row?.creator || '').trim(),
create_time: row?.create_time || null,
update_time: row?.update_time || null,
order_count: orderCount,
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
review_assignment_status: orderCount === 0 || reviewedCount === 0
? 'unreviewed'
: reviewedCount >= orderCount
? 'reviewed'
: 'partially_reviewed',
};
});
return this.success('ok', {
list,
pagination: {
page,
pageSize,
total,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
});
}
/**
* 从 Sequelize 模型解析 SQL 表名并安全转义。
* @param {Object} model Sequelize 模型对象。
* @return {string} 可直接拼接到 SQL 的表名(已做反引号转义)。
*/
resolveModelTableName(model) {
const rawTableName = model && typeof model.getTableName === 'function'
? model.getTableName()
: model && model.tableName;
const tableName = typeof rawTableName === 'string'
? rawTableName
: rawTableName && typeof rawTableName.tableName === 'string'
? rawTableName.tableName
: '';
const normalizedTableName = String(tableName || '').trim();
if (!normalizedTableName) {
throw new Error('订单模型表名解析失败');
}
const tableParts = normalizedTableName.split('.')
.map(part => String(part || '').trim())
.filter(Boolean);
if (tableParts.length === 0) {
throw new Error('订单模型表名解析失败');
}
for (const tablePart of tableParts) {
if (!/^[a-zA-Z0-9_$]+$/.test(tablePart)) {
throw new Error(`订单模型表名不合法: ${normalizedTableName}`);
}
}
return tableParts.map(part => `\`${part}\``).join('.');
}
/**
* 确认仓库拦截:通过订单ID直接匹配订单,将其拦截状态更新为"仓库拦截成功"。
* 仅拦截当前指定订单(不波及波次内其他订单)。
* @param {Object} data 请求体。
* @param {number} data.order_id 订单ID。
* @return {Promise<Object>} 拦截确认结果,包含 order_id、intercept_status 与更新时间。
*/
async confirmIntercept(data = {}) {
const { ctx } = this;
const { order_id } = data;
const warehouseId = this.getWarehouseId();
const orderId = Number(order_id);
if (!orderId || !Number.isFinite(orderId) || orderId <= 0) {
throw new Error('order_id 无效');
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
const order = await orderModel.findOne({
where: orderWhere,
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'intercept_status', 'wave_no' ],
raw: true,
});
if (!order) {
throw new Error('未找到对应订单');
}
const now = new Date();
const updateValues = {
intercept_status: 'intercepted_at_warehouse',
updated_at: now,
};
const updateResult = await orderModel.update(updateValues, {
where: orderWhere,
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
if (affectedRows <= 0) {
throw new Error('拦截状态更新失败,请稍后重试');
}
// 拦截成功后释放储位分配(归还库存)
try {
await this.service.systems.orderStorageAllocation.cancelAllocateStorage({
order_ids: [ orderId ],
});
} catch (allocErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 释放储位分配失败,不影响拦截, orderId=${orderId}, error=${allocErr.message}`
);
}
// 拦截成功后释放订单锁
try {
await orderModel.update(
{ lock_status: 'none', updated_at: now },
{ where: orderWhere }
);
} catch (lockErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 释放锁失败,不影响拦截, orderId=${orderId}, error=${lockErr.message}`
);
}
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
// 写入操作日志(失败不影响主流程)
try {
const operator = this.getOrderLogOperator();
const logWarehouseId = this.getOrderLogWarehouseId(warehouseId);
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: logWarehouseId,
operationCode: 'ORDER_INTERCEPT_CONFIRM',
operator,
extras: {
warehouseId: logWarehouseId,
orderId,
orderNo,
previousInterceptStatus: String(order.intercept_status || '').trim(),
newInterceptStatus: 'intercepted_at_warehouse',
},
beforeChanges: null,
});
} catch (logErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${logErr.message}`
);
}
return {
order_id: orderId,
order_no: orderNo,
intercept_status: 'intercepted_at_warehouse',
updated_at: now,
};
}
/**
* 批量快捷复核:对一批订单 IDs 依次执行前置条件检查与复核流程。
* 支持部分失败:不满足前置条件的订单直接跳过并记录失败原因,其余订单继续走完拣货完成 + 复核标记流程。
*
* 前置条件(任一不满足即跳过):
* 1. 未分配储位:storage_status 不等于 'fin'
* 2. 未分配快递:post_status 不等于 'fin'
* 3. 未同步:status 不等于 'created'
* 4. 已拦截:intercept_status 为 'intercepted' 或 'intercepted_at_warehouse'
*
* 核心流程(每个满足条件的订单在独立事务中执行):
* 1. 若 pick_status 不等于 'fin',先完成拣货:
* - 更新 wms_wave_pick_task_order 拣货状态(仅当订单关联拣货任务时)
* - 更新 wms_order_delivery.pick_status = 'fin'
* - 更新 wms_picking.status = 'fin'(仅当存在拣货记录时)
* - 汇总 wms_picking 中各 storage_id 的 quantity,扣减 wms_storage.locked_quantity 与 quantity
* - 写入 wms_storage_transaction 出库流水
* 2. 标记复核:
* - 更新 wms_order_delivery.recheck_status = 'fin'、recheck_time = now
* - 插入 wms_recheck_task 复核记录
* - 更新 wms_wave_pick_task_order 复核状态并尝试解绑车任务
* - 写入操作日志
*
* @param {Object} data 请求体。
* @param {number[]|string} data.ids 订单 ID 列表,支持数组或以逗号分隔的字符串。
* @return {Promise<Object>} 批量复核结果,包含 success、failed、success_count、failed_count。
*/
async batchQuickRecheck(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const orderIds = this.normalizeOrderIds(data);
if (orderIds.length === 0) {
this.ctx.throw(400, '订单ID列表不能为空');
}
// ── 1. 批量查询所有订单的当前状态 ──
const orderModel = await this.getOrderModel('order', warehouseId);
const orderRows = await orderModel.findAll({
where: this.buildOrderWhere(orderIds, warehouseId),
attributes: [
'id', 'delivery_order_code', 'pre_delivery_order_code',
'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status',
'pick_status', 'recheck_status', 'wave_id', 'wave_no',
],
raw: true,
});
const orderMap = new Map();
for (const row of orderRows) {
orderMap.set(Number(row.id), row);
}
// ── 2. 前置条件检查:将订单分为有效订单与跳过订单 ──
const validOrders = [];
const failedOrders = [];
for (const orderId of orderIds) {
const order = orderMap.get(orderId);
if (!order) {
failedOrders.push({ order_id: orderId, reason: '未找到对应订单' });
continue;
}
const interceptStatus = String(order.intercept_status || '').trim();
if (interceptStatus === 'intercepted' || interceptStatus === 'intercepted_at_warehouse') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '已拦截',
});
continue;
}
const storageStatus = String(order.storage_status || '').trim();
if (storageStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '未分配储位',
});
continue;
}
const postStatus = String(order.post_status || '').trim();
if (postStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有分配快递',
});
continue;
}
const syncStatus = String(order.sync_status || '').trim();
if (syncStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有同步',
});
continue;
}
validOrders.push(order);
}
// ── 3. 逐订单在独立事务中执行拣货完成 + 复核标记 ──
const successOrders = [];
for (const order of validOrders) {
const orderId = Number(order.id);
try {
await ctx.model.transaction(async transaction => {
// 3a. 若未完成拣货,先执行拣货完成流程
const pickStatus = String(order.pick_status || '').trim();
if (pickStatus !== 'fin') {
await this._completePickForOrder(orderId, warehouseId, transaction);
// 更新内存中的 pick_status,避免后续 assertOrderCanRecheck 因旧值误判
order.pick_status = 'fin';
}
// 3b. 标记复核
await this._markRecheckForOrder(order, warehouseId, transaction);
});
successOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
});
} catch (error) {
ctx.logger.warn(
`[batchQuickRecheck] 订单复核失败, orderId=${orderId}, error=${error.message}`
);
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: `复核失败: ${error.message}`,
});
}
}
return {
success: successOrders,
failed: failedOrders,
success_count: successOrders.length,
failed_count: failedOrders.length,
};
}
/**
* 规范波次 ID 入参,兼容 wave_ids、waveIds、wave_id 等写法。
* @param {Object} data 请求体。
* @return {number[]} 波次 ID 列表。
*/
normalizeWaveIds(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const rawIds = requestData.wave_ids;
const sourceIds = [];
if (Array.isArray(rawIds)) {
sourceIds.push(...rawIds);
} else if (typeof rawIds === 'string') {
sourceIds.push(...rawIds.split(','));
} else if (rawIds !== undefined && rawIds !== null && rawIds !== '') {
sourceIds.push(rawIds);
} else if (requestData.waveIds !== undefined && requestData.waveIds !== null && requestData.waveIds !== '') {
const val = requestData.waveIds;
if (Array.isArray(val)) sourceIds.push(...val);
else if (typeof val === 'string') sourceIds.push(...val.split(','));
else sourceIds.push(val);
} else if (requestData.wave_id !== undefined && requestData.wave_id !== null && requestData.wave_id !== '') {
sourceIds.push(requestData.wave_id);
}
const normalizedIds = [];
for (const value of sourceIds) {
const normalizedId = Number(String(value).trim());
if (Number.isFinite(normalizedId) && normalizedId > 0) {
normalizedIds.push(normalizedId);
}
}
return Array.from(new Set(normalizedIds));
}
/**
* 按波次批量快捷复核:传入波次 IDs 列表,对每个波次下所有有效订单执行前置检查
* (已分配储位、已分配快递、已同步且未被拦截),必要时自动完成拣货(含库存锁定校验与扣减、
* 库存流水写入、拣货任务状态同步)后标记复核(含复核任务记录、任务复核状态更新、车任务解绑、
* 操作日志)。每个订单在独立事务中执行,支持部分失败,不满足条件的订单跳过并返回原因。
*
* @param {Object} data 请求体。
* @param {number[]|string} [data.wave_ids] 波次 ID 列表,支持数组或以逗号分隔的字符串。
* @param {number[]|string} [data.waveIds] 波次 ID 列表别名(驼峰写法)。
* @param {number} [data.wave_id] 单个波次 ID。
* @return {Promise<Object>} 处理结果,包含 success/failed 列表及计数。
*/
async batchQuickRecheckByWave(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const waveIds = this.normalizeWaveIds(data);
if (waveIds.length === 0) {
this.ctx.throw(400, '波次ID列表不能为空');
}
// ── 1. 批量查询所有波次下的订单 ──
const orderModel = await this.getOrderModel('order', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_id: { [this.app.Sequelize.Op.in]: waveIds },
warehouse_id: warehouseId,
},
attributes: [
'id', 'delivery_order_code', 'pre_delivery_order_code',
'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status',
'pick_status', 'recheck_status', 'wave_id', 'wave_no',
],
raw: true,
});
// 按 wave_id 分组
const waveOrderMap = new Map();
for (const row of orderRows) {
const wid = Number(row.wave_id);
if (!waveOrderMap.has(wid)) {
waveOrderMap.set(wid, []);
}
waveOrderMap.get(wid).push(row);
}
// ── 2. 前置条件检查:逐波次、逐订单校验 ──
const allSuccessOrders = [];
const allFailedOrders = [];
for (const waveId of waveIds) {
const waveOrders = waveOrderMap.get(waveId) || [];
if (waveOrders.length === 0) {
allFailedOrders.push({
wave_id: waveId,
reason: '波次下无订单',
});
continue;
}
const validOrders = [];
for (const order of waveOrders) {
const orderId = Number(order.id);
const interceptStatus = String(order.intercept_status || '').trim();
if (interceptStatus === 'intercepted' || interceptStatus === 'intercepted_at_warehouse') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '已拦截',
});
continue;
}
const storageStatus = String(order.storage_status || '').trim();
if (storageStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '未分配储位',
});
continue;
}
const postStatus = String(order.post_status || '').trim();
if (postStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有分配快递',
});
continue;
}
const syncStatus = String(order.sync_status || '').trim();
if (syncStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有同步',
});
continue;
}
validOrders.push(order);
}
// ── 3. 逐订单在独立事务中执行拣货完成 + 复核标记 ──
for (const order of validOrders) {
const orderId = Number(order.id);
try {
await ctx.model.transaction(async transaction => {
// 3a. 若未完成拣货,先执行拣货完成流程
const pickStatus = String(order.pick_status || '').trim();
if (pickStatus !== 'fin') {
await this._completePickForOrder(orderId, warehouseId, transaction);
// 更新内存中的 pick_status,避免后续 _markRecheckForOrder 因旧值误判
order.pick_status = 'fin';
}
// 3b. 标记复核
await this._markRecheckForOrder(order, warehouseId, transaction);
});
allSuccessOrders.push({
order_id: orderId,
wave_id: Number(order.wave_id) || waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
});
} catch (error) {
ctx.logger.warn(
`[batchQuickRecheckByWave] 订单复核失败, orderId=${orderId}, waveId=${waveId}, error=${error.message}`
);
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: `复核失败: ${error.message}`,
});
}
}
}
return {
success: allSuccessOrders,
failed: allFailedOrders,
success_count: allSuccessOrders.length,
failed_count: allFailedOrders.length,
};
}
/**
* 完成单个订单的拣货流程(内部方法,在事务中执行)。
* 包含:更新拣货任务订单状态、订单拣货状态、拣货记录状态、扣减库存锁定数量与可用数量、写库存流水。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _completePickForOrder(orderId, warehouseId, transaction) {
const { ctx, app } = this;
// 步骤1:若订单关联拣货任务,更新 wms_wave_pick_task_order 的拣货状态
const taskOrderRows = await ctx.model.query(
`SELECT id, task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
LIMIT 1`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const hasTaskOrder = Array.isArray(taskOrderRows) && taskOrderRows.length > 0;
if (hasTaskOrder) {
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET pick_status = 1,
picked_time = NOW(),
update_time = NOW()
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
// 步骤2:更新 wms_order_delivery.pick_status = 'fin'
const orderModel = await this.getOrderModel('order', warehouseId);
await orderModel.update(
{ pick_status: 'fin' },
{
where: this.buildOrderWhere([ orderId ], warehouseId),
transaction,
validate: false,
hooks: false,
}
);
// 步骤3:检查是否存在 wms_picking 记录(仅统计 pending 且未删除的记录)
const pickingRows = await ctx.model.query(
`SELECT id, storage_id, quantity, space_id
FROM wms_picking
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
AND status = 'pending'
AND deleted_at IS NULL`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
if (normalizedPickingRows.length > 0) {
// 更新 wms_picking.status = 'fin'(仅更新 pending 且未删除的记录)
await ctx.model.query(
`UPDATE wms_picking
SET status = 'fin', updated_at = NOW()
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
AND status = 'pending'
AND deleted_at IS NULL`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
// 步骤4:汇总各 storage_id 的 quantity,扣减 wms_storage 锁定数量与可用数量
const storageQtyMap = new Map();
for (const row of normalizedPickingRows) {
const sid = Number(row.storage_id);
if (!sid || sid <= 0) continue;
const currentQty = storageQtyMap.get(sid) || 0;
storageQtyMap.set(sid, currentQty + (Number(row.quantity) || 0));
}
const storageIds = Array.from(storageQtyMap.keys());
if (storageIds.length > 0) {
// 加行锁查询当前库存
const storageRows = await ctx.model.Storage.findAll({
where: {
id: { [app.Sequelize.Op.in]: storageIds },
warehouse_id: warehouseId,
},
attributes: [
'id', 'locked_quantity', 'quantity',
'store_id', 'stock_id', 'batch_no', 'inventory_type', 'space_id',
],
lock: transaction.LOCK.UPDATE,
raw: true,
transaction,
});
// 校验锁定数量是否足够
for (const sRow of storageRows) {
const sid = Number(sRow.id);
const deduction = storageQtyMap.get(sid) || 0;
const locked = Number(sRow.locked_quantity) || 0;
if (locked < deduction) {
throw new Error(
`库存记录 ${sid} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`
);
}
}
// 构建 CASE WHEN 批量扣减
const summaryEntries = Array.from(storageQtyMap.entries());
const caseClauses = summaryEntries
.map(([ sid, qty ]) => `WHEN ${sid} THEN ${qty}`)
.join(' ');
await ctx.model.query(
`UPDATE wms_storage
SET locked_quantity = locked_quantity - CASE id ${caseClauses} END,
quantity = quantity - CASE id ${caseClauses} END,
updated_at = NOW()
WHERE id IN (:storageIds)
AND warehouse_id = :warehouseId`,
{
replacements: { storageIds, warehouseId },
transaction,
}
);
// 写入 wms_storage_transaction 出库流水
const operator = this.getOrderLogOperator();
const operatorId = String(operator.id || '').trim();
const operatorName = String(operator.name || 'system').trim();
const transactionRows = [];
for (const sRow of storageRows) {
const sid = Number(sRow.id);
const deduction = storageQtyMap.get(sid) || 0;
if (deduction <= 0) continue;
const beforeQty = Number(sRow.quantity) || 0;
const beforeLocked = Number(sRow.locked_quantity) || 0;
transactionRows.push({
transaction_type: 'OUTBOUND',
warehouse_id: warehouseId,
store_id: Number(sRow.store_id) || 0,
stock_id: Number(sRow.stock_id) || 0,
storage_id: sid,
space_id: Number(sRow.space_id) || null,
quantity: deduction,
before_quantity: beforeQty,
after_quantity: Math.max(0, beforeQty - deduction),
before_locked_quantity: beforeLocked,
after_locked_quantity: Math.max(0, beforeLocked - deduction),
batch_no: sRow.batch_no || null,
inventory_type: sRow.inventory_type || 'ZP',
order_type: 'PICK_OUTBOUND',
order_no: String(orderId),
order_id: orderId,
source_order_codes: String(orderId),
operator_id: operatorId,
operator_name: operatorName,
remark: '拣货完成出库(批量快捷复核)',
created_at: new Date(),
});
}
if (transactionRows.length > 0) {
await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction });
}
}
}
// 写入 order_operation_log 拣货完成日志(双写)
try {
const operationLogService = ctx.service
&& ctx.service.systems
&& ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logOperator = this.getOrderLogOperator();
const operatorId = String(logOperator.id || '').trim();
const operatorName = String(logOperator.name || 'system').trim();
await operationLogService.createOperationLogs([
{
businessType: 'order',
businessId: `${orderId}`,
operationCode: 'ORDER_PICK_COMPLETE',
operator: { id: operatorId || null, name: operatorName || 'system' },
extras: {
message: `订单${orderId}拣货完成`,
warehouseId: Number(warehouseId),
externalLogType: 'API',
},
},
], { transaction });
}
} catch (e) {
ctx.logger.warn(
`[_completePickForOrder] order_operation_log 写入失败, orderId=${orderId}, error=${e.message}`
);
}
// 步骤5:更新 wms_wave_pick_task 状态
if (hasTaskOrder) {
const taskId = Number(taskOrderRows[0]?.task_id || 0);
if (taskId > 0) {
// 检查该任务下是否所有订单都已完成拣货
const taskOrderCount = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND pick_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const allPicked = (Number(taskOrderCount[0]?.cnt || 0)) === 0;
if (allPicked) {
// 全部完成 → 任务状态设为已完成
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET status = 2,
finish_time = NOW(),
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
} else {
// 未全部完成 → 任务状态推进为拣货中(若仍为未开始)
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET status = CASE WHEN status = 0 THEN 1 ELSE status END,
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
}
}
}
/**
* 标记单个订单为已复核(内部方法,在事务中执行)。
* 包含:更新订单复核状态、插入复核任务记录、更新拣货任务复核状态并尝试解绑车任务、写操作日志。
*
* @param {Object} order 订单信息行。
* @param {number} warehouseId 仓库ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _markRecheckForOrder(order, warehouseId, transaction) {
const { ctx } = this;
const orderId = Number(order.id);
// 校验订单是否允许复核(拣货已完成且未被拦截)
this.assertOrderCanRecheck(order);
const now = new Date();
// 更新订单复核状态
const orderModel = await this.getOrderModel('order', warehouseId);
await orderModel.update(
{
recheck_status: 'fin',
print_status: 'fin',
recheck_time: now,
updated_at: now,
},
{
where: this.buildOrderWhere([ orderId ], warehouseId),
transaction,
validate: false,
hooks: false,
}
);
// 插入 wms_recheck_task 复核记录
const operator = this.getOrderLogOperator();
const reviewNo = this.buildRecheckReviewNo(orderId, now);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const operatorNo = String(operator.id || '').trim();
const operatorName = String(operator.name || '').trim();
await ctx.model.query(
`INSERT INTO wms_recheck_task (
review_no,
warehouse_id,
order_id,
order_no,
waybill_no,
task_status,
scan_status,
review_emp_no,
review_emp_name,
scan_emp_no,
scan_emp_name,
scan_time,
finish_time,
remark
) VALUES (
:reviewNo,
:warehouseId,
:orderId,
:orderNo,
:waybillNo,
:taskStatus,
:scanStatus,
:reviewEmpNo,
:reviewEmpName,
:scanEmpNo,
:scanEmpName,
:scanTime,
:finishTime,
:remark
)`,
{
replacements: {
reviewNo,
warehouseId,
orderId,
orderNo,
waybillNo: '',
taskStatus: 2,
scanStatus: 1,
reviewEmpNo: operatorNo,
reviewEmpName: operatorName,
scanEmpNo: operatorNo,
scanEmpName: operatorName,
scanTime: now,
finishTime: now,
remark: '系统复核完成(批量快捷复核)',
},
type: ctx.model.QueryTypes.INSERT,
transaction,
}
);
// 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务
await this._updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction);
// 写入操作日志
await this._writeRecheckActionLogInTransaction({
orderId,
warehouseId,
operator,
now,
transaction,
});
// 散单复核完成后,在事务内检查订单所属波次下所有订单是否均已复核完成,
// 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失
await this._tryCompleteWaveInTransaction(orderId, order.wave_id, warehouseId, operator, now, transaction);
}
/**
* 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成,
* 若全部完成则更新 wms_wave_batch.wave_status = 5(复核完成),
* 使该波次从 batchList 中自然消失。
*
* @param {number} orderId 当前复核的订单ID。
* @param {number|string|null} waveId 订单所属波次ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async _tryCompleteWaveIfAllOrdersRechecked(orderId, waveId, warehouseId, operator, now) {
const { ctx } = this;
const normalizedWaveId = Number(waveId);
if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) {
return;
}
// 查询波次下是否还有未复核的订单(recheck_status != 'fin')
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const unreviewedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
});
if (unreviewedCount > 0) {
return;
}
// 波次下所有订单均已复核完成,查询已完成订单数并更新波次状态
const processedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: 'fin',
},
});
const operatorName = String(operator.name || operator.id || '').trim();
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = 5,
check_operator = :operatorName,
check_time = :now,
processed_orders = :processedCount,
update_time = :now
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId`,
{
replacements: {
waveId: normalizedWaveId,
warehouseId,
operatorName,
processedCount,
now,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
ctx.logger.info(
`[confirmRecheck] 波次复核完成, waveId=${normalizedWaveId}, orderId=${orderId}, processedCount=${processedCount}`
);
}
/**
* 在事务内检查订单所属波次下所有订单是否均已复核完成,
* 若全部完成则更新 wms_wave_batch.wave_status = 5(复核完成)。
* 用于批量快捷复核(batchQuickRecheck)事务内的散单路径。
*
* @param {number} orderId 当前复核的订单ID。
* @param {number|string|null} waveId 订单所属波次ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _tryCompleteWaveInTransaction(orderId, waveId, warehouseId, operator, now, transaction) {
const { ctx } = this;
const normalizedWaveId = Number(waveId);
if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) {
return;
}
// 在事务内查询波次下是否还有未复核的订单(recheck_status != 'fin')
const orderModel = await this.getOrderModel('order', warehouseId);
const unreviewedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
transaction,
});
if (unreviewedCount > 0) {
return;
}
// 波次下所有订单均已复核完成,查询已完成订单数并更新波次状态
const processedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: 'fin',
},
transaction,
});
const operatorName = String(operator.name || operator.id || '').trim();
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = 5,
check_operator = :operatorName,
check_time = :now,
processed_orders = :processedCount,
update_time = :now
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId`,
{
replacements: {
waveId: normalizedWaveId,
warehouseId,
operatorName,
processedCount,
now,
},
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
ctx.logger.info(
`[batchQuickRecheck] 波次复核完成, waveId=${normalizedWaveId}, orderId=${orderId}, processedCount=${processedCount}`
);
}
/**
* 在事务中更新波次拣货任务订单的复核状态,并判断是否需要解绑车任务。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction) {
const { ctx } = this;
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const hasReviewStatus = taskOrderColumnSet.has('review_status');
if (!hasReviewStatus) {
return;
}
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
const hasReviewResult = taskOrderColumnSet.has('review_result');
const hasReviewTime = taskOrderColumnSet.has('review_time');
const operatorUserId = Number(operator.id) || 0;
const reviewSetClauses = [ 'review_status = 1' ];
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
reviewSetClauses.push('update_time = NOW()');
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET ${reviewSetClauses.join(',\n ')}
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: {
orderId,
warehouseId,
operatorUserId,
now,
},
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const taskId = Number(
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单所属波次查找关联的拣货任务(回退查询使用独立连接,不参与当前事务)
let resolvedTaskId = taskId;
if (resolvedTaskId <= 0) {
resolvedTaskId = await this._resolveTaskIdByWaveFallback(orderId, warehouseId);
}
if (resolvedTaskId <= 0) {
return;
}
// 检查该任务下是否所有订单都已复核完成
const allReviewed = await this._checkTaskOrdersAllReviewed(resolvedTaskId, warehouseId);
if (!allReviewed) {
return;
}
// 任务下所有订单均已复核完成,解绑车任务
try {
await this._unbindCartForTaskInTransaction(resolvedTaskId, warehouseId, operatorUserId, transaction);
ctx.logger.info(
`[batchQuickRecheck] 车任务解绑成功, taskId=${resolvedTaskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[batchQuickRecheck] 解绑车任务失败(复核已成功), taskId=${resolvedTaskId}, orderId=${orderId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId: resolvedTaskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
/**
* 在事务中解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
*
* @param {number} taskId 波次拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @param {number} operatorUserId 操作员用户ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _unbindCartForTaskInTransaction(taskId, warehouseId, operatorUserId, transaction) {
const { ctx } = this;
// 停用拣货车绑定记录
await ctx.model.query(
`UPDATE wms_pick_task_cart_binding
SET is_active = 0,
unbind_user_id = :operatorUserId,
unbind_time = NOW(),
update_time = NOW()
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND is_active = 1`,
{
replacements: { taskId, warehouseId, operatorUserId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
/**
* 在事务中写入复核操作日志(内部方法)。
*
* @param {Object} params 日志参数。
* @param {number} params.orderId 订单ID。
* @param {number} params.warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
* @param {Date} params.now 操作时间。
* @param {Object} params.transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _writeRecheckActionLogInTransaction(params = {}) {
const { orderId, warehouseId, operator, now, transaction } = params;
const operatorId = operator && operator.id ? Number(operator.id) : 0;
const operatorName = operator && operator.name ? String(operator.name).trim() : 'system';
const requestId = `recheck_${warehouseId}_${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: null,
orderId: orderId || 0,
skuId: null,
locationId: null,
boxNo: null,
cartId: null,
qtyDelta: 0,
actionType: 'recheck',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify({
order_id: orderId,
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}),
},
type: this.ctx.model.QueryTypes.INSERT,
transaction,
}
);
// 双写 order_operation_log(失败不影响主流程)
try {
const ctx = this.ctx;
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId || ''),
operationCode: 'ORDER_RECHECK',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: '订单复核完成',
orderId: orderId || 0,
},
}], { transaction });
}
} catch (e) {
this.ctx.logger.warn('[recheckOrder._writeRecheckActionLogInTransaction] 写入 order_operation_log 失败', {
error: e && e.message,
orderId,
warehouseId,
});
}
}
}
module.exports = RecheckOrderService;