2313 lines
75 KiB
JavaScript
2313 lines
75 KiB
JavaScript
'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);
|
||
}
|
||
|
||
/**
|
||
* 扫描关键词并返回以波次为单位的复核视图。
|
||
* 支持运单号、波次号、车号三种匹配模式。
|
||
* - 运单号/波次号匹配(散单):返回匹配订单所在波次的所有订单,list_type='single',
|
||
* 顶层携带波次/拣货人/策略/任务ID等汇总信息,list 为扁平订单数组
|
||
* - 车号匹配(团单):返回拣货任务下所有团购波次及订单,list_type='group',保持嵌套结构,
|
||
* 顶层携带 task_id
|
||
* @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、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) {
|
||
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) {
|
||
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 = await this.buildGroupWaveList(taskId, warehouseId);
|
||
return {
|
||
match_type: 'cart',
|
||
list_type: 'group',
|
||
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、task_id、list 等字段,
|
||
* 散单模式额外包含 picker_id、picker_name、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 = await this.buildGroupWaveList(taskId, warehouseId);
|
||
|
||
return {
|
||
match_type: 'task',
|
||
list_type: 'group',
|
||
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;
|
||
|
||
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,
|
||
list: orders,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建单个波次的复核视图(散单/团单内部共用)。
|
||
* 查询波次信息、拣货模式、以及波次下全部订单列表。
|
||
* @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。
|
||
*/
|
||
async buildSingleWaveView(waveId, waveNo, warehouseId) {
|
||
const { ctx } = this;
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
const normalizedWaveNo = String(waveNo || '').trim();
|
||
|
||
if (normalizedWaveId <= 0 || !normalizedWaveNo) {
|
||
return null;
|
||
}
|
||
|
||
// 查询波次批次信息
|
||
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查找关联的所有波次,每个波次展开为一项。
|
||
* @param {number} taskId 拣货任务ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Array<Object>>} 波次视图列表。
|
||
*/
|
||
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 || !twWaveNo) {
|
||
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);
|
||
}
|
||
|
||
// 使用任务级别的 pick_mode 覆盖(团单模式下以任务为准)
|
||
return {
|
||
...waveView,
|
||
pick_mode: pickMode,
|
||
box_no: Number(tw.box_no || 0),
|
||
};
|
||
});
|
||
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* 查询波次下所有订单的基本信息列表。
|
||
* 包含运单号、打印状态、复核状态、波次内序号(优先从 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,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 查询波次关联的策略信息。
|
||
* 当前 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);
|
||
}
|
||
|
||
/**
|
||
* 确认订单已复核,并写入复核任务记录。
|
||
* @param {Object} data 请求体。
|
||
* @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 { ctx } = this;
|
||
const warehouseId = this.getWarehouseId();
|
||
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);
|
||
|
||
return {
|
||
order_id: orderId,
|
||
waybill_no: waybillNo,
|
||
recheck_status: 'fin',
|
||
recheck_time: now,
|
||
review_no: reviewNo,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 更新波次拣货任务订单的复核状态,若任务下所有订单均已复核完成则自动解绑车任务。
|
||
* @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}`
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
|
||
* @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');
|
||
const taskRows = 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,
|
||
}
|
||
);
|
||
|
||
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
|
||
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 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;
|