liufumingren 43c60dd934 1
2026-06-09 14:12:02 +08:00

3088 lines
102 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';
const _noNeedLog = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept';
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 扫描关键词并返回以波次为单位的复核视图。
* 支持运单号、波次号、车号三种匹配模式,并根据波次拣货模式自动分派散单/团购视图。
* - 运单号/波次号命中散单波次(pick_mode=2/3/4):返回扁平化订单列表 list_type='single',
* 顶层携带波次/拣货人/策略/任务ID等汇总信息,list 为扁平订单数组
* - 运单号/波次号命中团购波次(pick_mode=1/5):自动转为团购模式,
* 返回嵌套波次结构 list_type='group',每项含波次号、波次内订单明细(含 stock 商品明细)及相关汇总信息
* - 车号匹配(团单):返回拣货任务下所有团购波次及订单,list_type='group',保持嵌套结构,
* 顶层携带 picker_id、picker_name、task_id
* - 运单号命中但订单无波次信息时,退回单订单详情模式(list 每项含 detail/items/expresses/logs)
* @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 数组。
*/
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', '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,
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 });
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [{
...(detailResult.detail || {}),
items: Array.isArray(detailResult.items) ? detailResult.items : [],
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
}],
};
}
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 });
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [{
...(detailResult.detail || {}),
items: Array.isArray(detailResult.items) ? detailResult.items : [],
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
}],
};
}
// 波次号匹配 → 直接按波次号查找波次及订单(散单/团购分流)
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('波次信息不完整,无法加载复核视图');
}
// 团单处理:车号匹配 → 查找拣货任务 → 拉取任务下所有团购波次
if (matchType === 'cart' && cartMatchContext) {
const taskId = Number(cartMatchContext?.task?.task_id || 0);
if (taskId > 0) {
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,
};
}
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、list。
*/
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;
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: orders,
};
}
/**
* 构建单个波次的复核视图(散单/团单内部共用)。
* 查询波次信息、拣货模式、以及波次下全部订单列表。
* 当 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 等字段)。
*/
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 : [];
for (const order of orders) {
this.assertOrderCanRecheck(order);
}
// 分离拦截订单与非拦截订单
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);
}
}
// 团购波次中所有订单商品一致,取第一个正常订单的商品明细作为样板
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),
}));
// 构建拦截订单列表
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(),
}));
// 提取正常(非拦截)订单的 ID 列表
const orderIds = normalOrders.map(order => Number(order.order_id || 0)).filter(id => id > 0);
// 计算波次内复核统计(基于非拦截订单的 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),
order_ids: orderIds,
stocks,
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
printed_count: printedCount,
unprinted_count: unprintedCount,
};
// 仅当存在拦截订单时才追加 intercepted 字段
if (intercepted.length > 0) {
result.intercepted = intercepted;
}
return result;
});
const waveViews = await Promise.all(waveViewPromises);
return waveViews.filter(view => view !== null);
}
/**
* 通过波次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、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,
},
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',
],
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 },
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_remark: storeRemarkMap.has(Number(row.store_id || 0))
? storeRemarkMap.get(Number(row.store_id || 0))
: '',
intercept_status: String(row.intercept_status || '').trim(),
};
});
// 排序:未复核的排前面,其次按波次内序号从小到大
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;
}
/**
* 为订单列表批量补充库存信息。
* 查询每个订单的明细商品、库存数量、条码列表和图片,构建 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' ],
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. 批量查询库存信息
const stockMap = new Map();
if (stockIds.length > 0 && this.ctx.model && this.ctx.model.StockWarehouse) {
const stockRows = await this.ctx.model.StockWarehouse.findAll({
where: {
id: { [this.app.Sequelize.Op.in]: stockIds },
warehouse_id: warehouseId,
},
attributes: [ 'id', 'item_code', 'item_name', 'sku_property', 'packing_requirements' ],
raw: true,
});
for (const row of (Array.isArray(stockRows) ? stockRows : [])) {
stockMap.set(Number(row.id), row);
}
}
// 4. 批量查询条码
const barcodeMap = new Map();
if (stockIds.length > 0 && this.ctx.model && this.ctx.model.StockBarcode) {
const barcodeRows = await this.ctx.model.StockBarcode.findAll({
where: {
stock_id: { [this.app.Sequelize.Op.in]: stockIds },
warehouse_id: warehouseId,
},
attributes: [ 'stock_id', 'barcode' ],
raw: true,
});
for (const row of (Array.isArray(barcodeRows) ? barcodeRows : [])) {
const sid = Number(row.stock_id);
const barcodeVal = String(row.barcode || '').trim();
if (!barcodeMap.has(sid)) {
barcodeMap.set(sid, []);
}
if (barcodeVal) {
barcodeMap.get(sid).push(barcodeVal);
}
}
}
// 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. 批量查询图片
const imagesByStockId = await this.getOrderItemImagesByStockIds(itemsArray);
// 7. 按 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);
}
// 8. 为每个订单构建 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),
};
});
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,
});
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,
}
);
}
/**
* 更新波次拣货任务订单的复核状态,若任务下所有订单均已复核完成则自动解绑车任务。
* @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,
}
);
const taskId = Number(
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
);
if (taskId <= 0) {
return;
}
// 检查该任务下是否所有订单都已复核完成
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) {
return;
}
// 任务下所有订单均已复核完成,解绑车任务(失败不影响主流程)
try {
await this.unbindCartForTask(taskId, warehouseId, operatorUserId);
ctx.logger.info(
`[confirmRecheck] 车任务解绑成功, taskId=${taskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[confirmRecheck] 解绑车任务失败(复核已成功), taskId=${taskId}, orderId=${orderId}, error=${unbindError.message}`
);
}
}
/**
* 批量更新波次拣货任务订单的复核状态,并按任务维度检查是否需要解绑车任务。
* 与单订单版本不同,本方法一次性更新所有相关任务订单的 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,
}
);
const taskIds = (Array.isArray(taskRows) ? taskRows : [])
.map(r => Number(r.task_id || 0))
.filter(id => id > 0);
// 逐任务判断是否所有订单均已复核完成
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}`
);
}
}
}
/**
* 解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
* @param {number} taskId 波次拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @param {number} operatorUserId 操作员用户ID。
* @return {Promise<void>} 无返回值。
*/
async unbindCartForTask(taskId, warehouseId, operatorUserId) {
const { ctx } = this;
// 1. 清空波次拣货任务的车绑定信息
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET current_cart_id = NULL,
current_cart_code_snapshot = NULL,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
}
);
// 2. 停用拣货车绑定记录
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,
}
);
// 3. 释放拣货车(清空当前任务和绑定用户)
await ctx.model.query(
`UPDATE wms_pick_cart
SET current_task_id = NULL,
bind_user_id = NULL,
last_seen_time = NOW(),
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND current_task_id = :taskId`,
{
replacements: { taskId, warehouseId },
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_wave_pick_task.current_cart_code_snapshot(任务主表车号快照)
* 2. wms_wave_pick_task_order.cart_code_snapshot(任务订单行车号快照,仅散单模式有数据)
* 3. wms_pick_task_cart_binding(车任务绑定表,所有模式均有记录,回退兜底)
* @param {string} cartCode 车号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 任务行,未找到返回 null。
*/
const findTaskByCartCode = async (cartCode, warehouseId) => {
// 第一优先级:任务主表车号快照 + 任务订单行车号快照
const primaryRows = 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,
}
);
if (Array.isArray(primaryRows) && primaryRows.length > 0) {
return primaryRows[0];
}
// 第二优先级(回退):车任务绑定表(覆盖小团购等无 wms_wave_pick_task_order 记录的场景)
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.is_active = 1
ORDER BY b.create_time DESC, b.id DESC
LIMIT 1
`,
{
replacements: { warehouseId, cartCode },
type: ctx.model.QueryTypes.SELECT,
}
);
return (Array.isArray(bindingRows) && bindingRows.length > 0) ? bindingRows[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('订单未拣货,不允许复核。');
}
}
/**
* 复核订单列表查询,通过入参 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.status,
o.create_at,
o.pick_time,
o.recheck_time
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),
status: Number(row?.status || 0),
create_at: row?.create_at || null,
pick_time: row?.pick_time || 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('拦截状态更新失败,请稍后重试');
}
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,
};
}
}
module.exports = RecheckOrderService;