4186 lines
141 KiB
JavaScript
4186 lines
141 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,batchQuickRecheck';
|
||
const _noNeedLog = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck';
|
||
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck';
|
||
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
|
||
}
|
||
|
||
/**
|
||
* 扫描关键词并返回以波次为单位的复核视图。
|
||
* 支持运单号、波次号、车号三种匹配模式,并根据波次拣货模式自动分派散单/团购视图。
|
||
* - 运单号/波次号命中散单波次(pick_mode=2/3/4):返回扁平化订单列表 list_type='single',
|
||
* 顶层携带波次/拣货人/策略/任务ID等汇总信息,list 为扁平订单数组
|
||
* - 运单号/波次号命中团购波次(pick_mode=1/5):自动转为团购模式,
|
||
* 返回嵌套波次结构 list_type='group',每项含波次号、波次内订单明细(含 stock 商品明细)及相关汇总信息
|
||
* - 车号匹配(团购模式 pick_mode=1/5):返回拣货任务下所有团购波次及订单,list_type='group',保持嵌套结构,
|
||
* 顶层携带 picker_id、picker_name、task_id
|
||
* - 车号匹配(散单模式 pick_mode=2/3/4):查询任务关联的所有波次,逐波次构建扫描视图后合并,
|
||
* 返回 list_type='single',按 order_id 去重,未复核订单排前,顶层携带汇总字段
|
||
* - 运单号命中但订单无波次信息时,退回单订单详情模式(list 每项含 detail/items/expresses/logs、
|
||
* items_weight、suggested_package_material)
|
||
* - 所有模式的 list[] 每项均附带 items_weight(订单商品总重量)与 suggested_package_material(推荐包材信息,无推荐时为 null)
|
||
* @param {Object} data 请求体。
|
||
* @param {string} [data.keyword] 通用扫描关键词。
|
||
* @param {string} [data.value] 通用扫描关键词别名。
|
||
* @param {string} [data.waybill_no] 运单号。
|
||
* @param {string} [data.waybillCode] 运单号别名。
|
||
* @param {string} [data.waybill_code] 运单号别名。
|
||
* @param {string} [data.wave_no] 波次号。
|
||
* @param {string} [data.waveNo] 波次号别名。
|
||
* @param {string} [data.cart_code] 车号。
|
||
* @param {string} [data.cartCode] 车号别名。
|
||
* @return {Promise<Object>} 扫描结果,包含 match_type、list_type、picker_id、picker_name、task_id(散单/团单均有)与 list 数组,
|
||
* list 每项含 items_weight、suggested_package_material。
|
||
*/
|
||
async scanOrder(data = {}) {
|
||
const warehouseId = this.getWarehouseId();
|
||
const keyword = this.resolveScanKeyword(data);
|
||
const matchedResult = await this.pickOrderMatchByKeyword(keyword);
|
||
const { orderId, matchType, cartMatchContext, waveMatchContext } = matchedResult;
|
||
|
||
// 散单处理:运单号匹配 → 查找订单所在波次 → 拉取波次全量订单
|
||
if (matchType === 'waybill') {
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const order = await orderModel.findOne({
|
||
where: this.buildOrderWhere([ orderId ], warehouseId),
|
||
attributes: [ 'id', 'wave_id', 'wave_no', 'pick_status', 'intercept_status', 'delivery_order_code' ],
|
||
raw: true,
|
||
});
|
||
|
||
if (!order) {
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
const orderWaveId = Number(order.wave_id || 0);
|
||
const orderWaveNo = String(order.wave_no || '').trim();
|
||
|
||
if (orderWaveId > 0 && orderWaveNo) {
|
||
// 检查波次是否为团购模式(pick_mode=1 团购小波次 / pick_mode=5 团购大波次)
|
||
const pickMode = await this.getPickModeByWaveId(orderWaveId, warehouseId);
|
||
if (pickMode === 1 || pickMode === 5) {
|
||
const groupTaskId = await this.getTaskIdByWaveId(orderWaveId, warehouseId);
|
||
if (groupTaskId > 0) {
|
||
const [ groupWaveList, pickerInfo ] = await Promise.all([
|
||
this.buildGroupWaveList(groupTaskId, warehouseId),
|
||
this.getPickerInfoByTaskId(groupTaskId, warehouseId),
|
||
]);
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'group',
|
||
waybill_no: keyword,
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: groupTaskId,
|
||
list: groupWaveList,
|
||
};
|
||
}
|
||
// 找不到拣货任务时退回单订单详情模式
|
||
this.assertOrderCanRecheck(order);
|
||
const detailResult = await this.detail({ id: orderId });
|
||
const fallbackOrder = detailResult.detail || {};
|
||
const fallbackPackageMap = await this.batchQueryPackageMaterialRecommendation(
|
||
[{ items_hash: fallbackOrder.items_hash, items_crc: fallbackOrder.items_crc }],
|
||
warehouseId
|
||
);
|
||
const fallbackItemHash = String(fallbackOrder.items_hash || '').trim();
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
waybill_no: keyword,
|
||
list: [{
|
||
...fallbackOrder,
|
||
items: Array.isArray(detailResult.items) ? detailResult.items : [],
|
||
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
|
||
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
|
||
suggested_package_material: fallbackItemHash
|
||
? (fallbackPackageMap.get(fallbackItemHash) || null)
|
||
: null,
|
||
}],
|
||
};
|
||
}
|
||
|
||
const scanView = await this.buildSingleWaveScanView(orderWaveId, orderWaveNo, warehouseId);
|
||
if (scanView) {
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
waybill_no: keyword,
|
||
...scanView,
|
||
};
|
||
}
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
waybill_no: keyword,
|
||
list: [],
|
||
};
|
||
}
|
||
|
||
// 无波次信息时退回单订单模式
|
||
this.assertOrderCanRecheck(order);
|
||
const detailResult = await this.detail({ id: orderId });
|
||
const noWaveOrder = detailResult.detail || {};
|
||
const noWavePackageMap = await this.batchQueryPackageMaterialRecommendation(
|
||
[{ items_hash: noWaveOrder.items_hash, items_crc: noWaveOrder.items_crc }],
|
||
warehouseId
|
||
);
|
||
const noWaveItemHash = String(noWaveOrder.items_hash || '').trim();
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
waybill_no: keyword,
|
||
list: [{
|
||
...noWaveOrder,
|
||
items: Array.isArray(detailResult.items) ? detailResult.items : [],
|
||
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
|
||
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
|
||
suggested_package_material: noWaveItemHash
|
||
? (noWavePackageMap.get(noWaveItemHash) || null)
|
||
: null,
|
||
}],
|
||
};
|
||
}
|
||
|
||
// 波次号匹配 → 直接按波次号查找波次及订单(散单/团购分流)
|
||
if (matchType === 'wave') {
|
||
const waveId = Number(waveMatchContext?.wave?.wave_id || 0);
|
||
const waveNo = String(waveMatchContext?.wave?.wave_no || '').trim();
|
||
|
||
if (waveId > 0 && waveNo) {
|
||
// 检查波次是否为团购模式(pick_mode=1 团购小波次 / pick_mode=5 团购大波次)
|
||
const pickMode = await this.getPickModeByWaveId(waveId, warehouseId);
|
||
if (pickMode === 1 || pickMode === 5) {
|
||
const groupTaskId = await this.getTaskIdByWaveId(waveId, warehouseId);
|
||
if (groupTaskId > 0) {
|
||
const [ groupWaveList, pickerInfo ] = await Promise.all([
|
||
this.buildGroupWaveList(groupTaskId, warehouseId),
|
||
this.getPickerInfoByTaskId(groupTaskId, warehouseId),
|
||
]);
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'group',
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: groupTaskId,
|
||
list: groupWaveList,
|
||
};
|
||
}
|
||
throw new Error('团购波次未找到对应拣货任务,无法加载复核视图');
|
||
}
|
||
|
||
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
|
||
if (scanView) {
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
...scanView,
|
||
};
|
||
}
|
||
return {
|
||
match_type: matchType,
|
||
list_type: 'single',
|
||
list: [],
|
||
};
|
||
}
|
||
|
||
throw new Error('波次信息不完整,无法加载复核视图');
|
||
}
|
||
|
||
// 车号匹配 → 查找拣货任务 → 根据 pick_mode 分流团单/散单
|
||
if (matchType === 'cart' && cartMatchContext) {
|
||
const taskId = Number(cartMatchContext?.task?.task_id || 0);
|
||
|
||
if (taskId > 0) {
|
||
const pickMode = Number(cartMatchContext?.task?.pick_mode || 0);
|
||
const { ctx } = this;
|
||
|
||
// 团购模式(pick_mode 1/5):拉取任务下所有团购波次
|
||
if (pickMode === 1 || pickMode === 5) {
|
||
const [ groupWaveList, pickerInfo ] = await Promise.all([
|
||
this.buildGroupWaveList(taskId, warehouseId),
|
||
this.getPickerInfoByTaskId(taskId, warehouseId),
|
||
]);
|
||
return {
|
||
match_type: 'cart',
|
||
list_type: 'group',
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: taskId,
|
||
list: groupWaveList,
|
||
};
|
||
}
|
||
|
||
// 散单模式(pick_mode 2/3/4):查询任务关联的波次,逐波次构建扫描视图并合并
|
||
const taskWaveRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no
|
||
FROM wms_wave_pick_task_wave
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
ORDER BY wave_id ASC
|
||
`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
|
||
const scanViews = [];
|
||
|
||
for (const tw of taskWaves) {
|
||
const waveId = Number(tw.wave_id || 0);
|
||
const waveNo = String(tw.wave_no || '').trim();
|
||
|
||
if (waveId > 0 && waveNo) {
|
||
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
|
||
|
||
if (scanView) {
|
||
scanViews.push(scanView);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (scanViews.length === 0) {
|
||
return {
|
||
match_type: 'cart',
|
||
list_type: 'single',
|
||
task_id: taskId,
|
||
pick_mode: pickMode,
|
||
list: [],
|
||
};
|
||
}
|
||
|
||
// 合并所有波次的订单列表(按 order_id 去重)
|
||
const allOrders = scanViews.flatMap(v => (Array.isArray(v.list) ? v.list : []));
|
||
const seenOrderIds = new Set();
|
||
const mergedList = [];
|
||
|
||
for (const order of allOrders) {
|
||
const oid = Number(order.order_id || 0);
|
||
|
||
if (oid > 0 && !seenOrderIds.has(oid)) {
|
||
seenOrderIds.add(oid);
|
||
mergedList.push(order);
|
||
}
|
||
}
|
||
|
||
// 排序:未复核的排前面,其次按 wave_index 从小到大
|
||
mergedList.sort((a, b) => {
|
||
const aReviewed = a.is_reviewed ? 1 : 0;
|
||
const bReviewed = b.is_reviewed ? 1 : 0;
|
||
|
||
if (aReviewed !== bReviewed) {
|
||
return aReviewed - bReviewed;
|
||
}
|
||
|
||
return (Number(a.wave_index || 0)) - (Number(b.wave_index || 0));
|
||
});
|
||
|
||
const totalOrders = mergedList.length;
|
||
const reviewedCount = mergedList.filter(o => o.recheck_status === 'fin').length;
|
||
const unreviewedCount = totalOrders - reviewedCount;
|
||
const waveType = scanViews.find(v => Number(v.wave_type || 0) > 0)?.wave_type || 0;
|
||
const pickerInfo = await this.getPickerInfoByTaskId(taskId, warehouseId);
|
||
|
||
return {
|
||
match_type: 'cart',
|
||
list_type: 'single',
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: taskId,
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
wave_type: Number(waveType || 0),
|
||
pick_mode: pickMode,
|
||
strategy_id: null,
|
||
strategy_name: '',
|
||
total_orders: totalOrders,
|
||
reviewed_count: reviewedCount,
|
||
unreviewed_count: unreviewedCount,
|
||
list: mergedList,
|
||
};
|
||
}
|
||
|
||
throw new Error('拣货任务信息不完整,无法加载复核视图');
|
||
}
|
||
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
/**
|
||
* 通过拣货任务ID刷新复核扫描视图。
|
||
* 根据任务的 pick_mode 区分散单/团单模式,返回与 scanOrder 一致的数据结构,用于前端刷新数据。
|
||
* - 散单模式(pick_mode 2/3/4):扁平化任务下所有波次的订单列表,顶层携带拣货人/任务等汇总信息
|
||
* - 团购模式(pick_mode 1/5):返回任务下所有团购波次及订单的分组列表
|
||
* @param {Object} data 请求体。
|
||
* @param {number} data.task_id 拣货任务ID。
|
||
* @return {Promise<Object>} 扫描视图,包含 match_type、list_type、picker_id、picker_name、task_id、list 等字段,
|
||
* 散单模式额外包含 pick_mode、total_orders、reviewed_count、unreviewed_count。
|
||
*/
|
||
async scanTask(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const taskId = Number(requestData.task_id || 0);
|
||
|
||
if (!Number.isFinite(taskId) || taskId <= 0) {
|
||
throw new Error('task_id 无效');
|
||
}
|
||
|
||
const warehouseId = this.getWarehouseId();
|
||
const { ctx } = this;
|
||
|
||
// 查询拣货任务信息
|
||
const taskRows = await ctx.model.query(
|
||
`
|
||
SELECT id AS task_id, pick_mode, pick_user_id, pick_user_name
|
||
FROM wms_wave_pick_task
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
|
||
|
||
if (!taskRow) {
|
||
throw new Error('未找到对应拣货任务');
|
||
}
|
||
|
||
const pickMode = Number(taskRow.pick_mode || 0);
|
||
|
||
// 查询任务关联的所有波次
|
||
const taskWaveRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no
|
||
FROM wms_wave_pick_task_wave
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
ORDER BY wave_id ASC
|
||
`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
|
||
|
||
// 团购模式(pick_mode 1 或 5):复用 buildGroupWaveList
|
||
if (pickMode === 1 || pickMode === 5) {
|
||
const [ groupWaveList, pickerInfo ] = await Promise.all([
|
||
this.buildGroupWaveList(taskId, warehouseId),
|
||
this.getPickerInfoByTaskId(taskId, warehouseId),
|
||
]);
|
||
|
||
return {
|
||
match_type: 'task',
|
||
list_type: 'group',
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: taskId,
|
||
list: groupWaveList,
|
||
};
|
||
}
|
||
|
||
// 散单模式(pick_mode 2、3、4):逐波次构建扫描视图并合并
|
||
const scanViews = [];
|
||
|
||
for (const tw of taskWaves) {
|
||
const waveId = Number(tw.wave_id || 0);
|
||
const waveNo = String(tw.wave_no || '').trim();
|
||
|
||
if (waveId > 0 && waveNo) {
|
||
const scanView = await this.buildSingleWaveScanView(waveId, waveNo, warehouseId);
|
||
|
||
if (scanView) {
|
||
scanViews.push(scanView);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (scanViews.length === 0) {
|
||
return {
|
||
match_type: 'task',
|
||
list_type: 'single',
|
||
task_id: taskId,
|
||
pick_mode: pickMode,
|
||
list: [],
|
||
};
|
||
}
|
||
|
||
// 合并所有波次的订单列表(按 order_id 去重)
|
||
const allOrders = scanViews.flatMap(v => (Array.isArray(v.list) ? v.list : []));
|
||
const seenOrderIds = new Set();
|
||
const mergedList = [];
|
||
|
||
for (const order of allOrders) {
|
||
const oid = Number(order.order_id || 0);
|
||
|
||
if (oid > 0 && !seenOrderIds.has(oid)) {
|
||
seenOrderIds.add(oid);
|
||
mergedList.push(order);
|
||
}
|
||
}
|
||
|
||
// 排序:未复核的排前面,其次按 wave_index 从小到大
|
||
mergedList.sort((a, b) => {
|
||
const aReviewed = a.is_reviewed ? 1 : 0;
|
||
const bReviewed = b.is_reviewed ? 1 : 0;
|
||
|
||
if (aReviewed !== bReviewed) {
|
||
return aReviewed - bReviewed;
|
||
}
|
||
|
||
return (Number(a.wave_index || 0)) - (Number(b.wave_index || 0));
|
||
});
|
||
|
||
const totalOrders = mergedList.length;
|
||
const reviewedCount = mergedList.filter(o => o.recheck_status === 'fin').length;
|
||
const unreviewedCount = totalOrders - reviewedCount;
|
||
const waveType = scanViews.find(v => Number(v.wave_type || 0) > 0)?.wave_type || 0;
|
||
|
||
return {
|
||
match_type: 'task',
|
||
list_type: 'single',
|
||
picker_id: taskRow.pick_user_id != null ? Number(taskRow.pick_user_id) : null,
|
||
picker_name: String(taskRow.pick_user_name || '').trim(),
|
||
task_id: taskId,
|
||
wave_id: 0,
|
||
wave_no: '',
|
||
wave_type: Number(waveType || 0),
|
||
pick_mode: pickMode,
|
||
strategy_id: null,
|
||
strategy_name: '',
|
||
total_orders: totalOrders,
|
||
reviewed_count: reviewedCount,
|
||
unreviewed_count: unreviewedCount,
|
||
list: mergedList,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建散单模式的扁平化扫描复核视图。
|
||
* 将波次信息、拣货人、策略、任务ID等提升到顶层,订单列表扁平化。
|
||
* @param {number} waveId 波次ID。
|
||
* @param {string} waveNo 波次号。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Object|null>} 扁平化扫描视图,包含 picker_id、picker_name、task_id、wave_id、wave_no、
|
||
* wave_type、pick_mode、strategy_id、strategy_name、total_orders、reviewed_count、unreviewed_count、
|
||
* printed_count、unprinted_count、list。
|
||
* list 中每项额外包含 items_weight(订单商品总重量)与 suggested_package_material(推荐包材信息,无推荐时为 null)。
|
||
*/
|
||
async buildSingleWaveScanView(waveId, waveNo, warehouseId) {
|
||
const baseWaveView = await this.buildSingleWaveView(waveId, waveNo, warehouseId);
|
||
|
||
if (!baseWaveView) {
|
||
return null;
|
||
}
|
||
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
const orders = Array.isArray(baseWaveView.orders) ? baseWaveView.orders : [];
|
||
|
||
// 校验波次内所有订单是否都已拣货,未拣货订单不允许复核
|
||
for (const order of orders) {
|
||
this.assertOrderCanRecheck(order);
|
||
}
|
||
|
||
// 并行查询拣货人信息和策略信息
|
||
const [ pickerInfo, strategyInfo ] = await Promise.all([
|
||
this.getPickerInfoByWaveId(normalizedWaveId, warehouseId),
|
||
this.getWaveStrategyInfo(normalizedWaveId, warehouseId),
|
||
]);
|
||
|
||
// 计算复核汇总
|
||
const reviewedCount = orders.filter(o => o.recheck_status === 'fin').length;
|
||
const unreviewedCount = orders.length - reviewedCount;
|
||
|
||
// 计算打印汇总
|
||
const printedCount = orders.filter(o => o.is_printed === true).length;
|
||
const unprintedCount = orders.length - printedCount;
|
||
|
||
// 批量查询包材推荐
|
||
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(orders, warehouseId);
|
||
|
||
// 为每个订单附加 items_weight 和包材推荐
|
||
const enrichedOrders = orders.map(order => {
|
||
const itemsHash = String(order.items_hash || '').trim();
|
||
return {
|
||
...order,
|
||
items_weight: order.items_weight != null ? Number(order.items_weight) : 0,
|
||
suggested_package_material: itemsHash ? (packageMaterialMap.get(itemsHash) || null) : null,
|
||
};
|
||
});
|
||
|
||
return {
|
||
picker_id: pickerInfo.picker_id,
|
||
picker_name: pickerInfo.picker_name,
|
||
task_id: pickerInfo.task_id,
|
||
wave_id: baseWaveView.wave_id,
|
||
wave_no: baseWaveView.wave_no,
|
||
wave_type: baseWaveView.wave_type,
|
||
pick_mode: baseWaveView.pick_mode,
|
||
strategy_id: strategyInfo.strategy_id,
|
||
strategy_name: strategyInfo.strategy_name,
|
||
total_orders: orders.length,
|
||
reviewed_count: reviewedCount,
|
||
unreviewed_count: unreviewedCount,
|
||
printed_count: printedCount,
|
||
unprinted_count: unprintedCount,
|
||
list: enrichedOrders,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建单个波次的复核视图(散单/团单内部共用)。
|
||
* 查询波次信息、拣货模式、以及波次下全部订单列表。
|
||
* 当 waveNo 为空但 waveId 有效时,通过 waveId 反查 wms_wave_batch 补全 waveNo。
|
||
* @param {number} waveId 波次ID。
|
||
* @param {string} waveNo 波次号,可为空字符串,为空时自动反查补全。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Object|null>} 波次视图对象,包含 wave_id、wave_no、wave_type、pick_mode、order_count、orders;
|
||
* 当 waveId 无效或 waveNo 无法补全时返回 null。
|
||
*/
|
||
async buildSingleWaveView(waveId, waveNo, warehouseId) {
|
||
const { ctx } = this;
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
|
||
if (normalizedWaveId <= 0) {
|
||
return null;
|
||
}
|
||
|
||
// 解析 waveNo,为空时通过 waveId 反查 wms_wave_batch 补全
|
||
let normalizedWaveNo = String(waveNo || '').trim();
|
||
if (!normalizedWaveNo) {
|
||
const fallbackRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_no
|
||
FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const fallbackRow = Array.isArray(fallbackRows) && fallbackRows.length > 0 ? fallbackRows[0] : null;
|
||
if (!fallbackRow || !fallbackRow.wave_no) {
|
||
return null;
|
||
}
|
||
normalizedWaveNo = String(fallbackRow.wave_no).trim();
|
||
}
|
||
|
||
// 查询波次批次信息
|
||
const waveRows = await ctx.model.query(
|
||
`
|
||
SELECT
|
||
wave_id,
|
||
wave_no,
|
||
wave_type,
|
||
wave_status,
|
||
total_orders,
|
||
processed_orders,
|
||
creator,
|
||
create_time,
|
||
update_time
|
||
FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
AND wave_no = :waveNo
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, waveNo: normalizedWaveNo, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
|
||
|
||
if (!waveRow) {
|
||
return null;
|
||
}
|
||
|
||
// 查询波次关联的拣货任务,获取 pick_mode
|
||
const pickMode = await this.getPickModeByWaveId(normalizedWaveId, warehouseId);
|
||
|
||
// 查询波次下所有订单
|
||
const orders = await this.getWaveOrdersBasic(normalizedWaveNo, warehouseId);
|
||
const orderCount = orders.length;
|
||
|
||
return {
|
||
wave_id: Number(waveRow.wave_id || 0),
|
||
wave_no: String(waveRow.wave_no || '').trim(),
|
||
wave_type: Number(waveRow.wave_type || 0),
|
||
wave_status: Number(waveRow.wave_status || 0),
|
||
pick_mode: pickMode,
|
||
total_orders: Number(waveRow.total_orders || 0),
|
||
processed_orders: Number(waveRow.processed_orders || 0),
|
||
creator: String(waveRow.creator || '').trim(),
|
||
create_time: waveRow.create_time || null,
|
||
update_time: waveRow.update_time || null,
|
||
order_count: orderCount,
|
||
orders,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建团购波次列表视图(团单模式)。
|
||
* 根据拣货任务ID查找关联的所有波次,每个波次展开为一项。
|
||
* 波次内非拦截订单的商品明细按 stock_id 合并,plan_qty 累加,直接输出 stocks 数组;
|
||
* 拦截订单单独输出 intercepted 列表。
|
||
* @param {number} taskId 拣货任务ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Array<Object>>} 波次视图列表,每项包含 wave_id、wave_no、wave_type、wave_status、
|
||
* pick_mode、total_orders、processed_orders、creator、create_time、update_time、
|
||
* order_count、box_no、reviewed_count、unreviewed_count、printed_count、unprinted_count、
|
||
* stocks(非拦截订单合并后的商品明细)、
|
||
* intercepted(拦截订单列表,仅当波次中存在拦截订单时出现,每项含 wave_index、order_id、
|
||
* delivery_order_code、intercept_status 等字段)、
|
||
* items_weight(订单商品总重量,取自波次内首个正常订单)、
|
||
* suggested_package_material(推荐包材信息,无推荐时为 null)、
|
||
* first_waybill_no(波次内首个正常订单的运单号,用于包材绑定等后续操作,无正常订单时为第一个订单的运单号,均无则为空字符串)。
|
||
*/
|
||
async buildGroupWaveList(taskId, warehouseId) {
|
||
const { ctx } = this;
|
||
const normalizedTaskId = Number(taskId || 0);
|
||
|
||
if (normalizedTaskId <= 0) {
|
||
return [];
|
||
}
|
||
|
||
// 查询拣货任务信息,获取 pick_mode
|
||
const taskRows = await ctx.model.query(
|
||
`
|
||
SELECT id AS task_id, pick_mode, current_cart_code_snapshot
|
||
FROM wms_wave_pick_task
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { taskId: normalizedTaskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
|
||
|
||
if (!taskRow) {
|
||
return [];
|
||
}
|
||
|
||
const pickMode = Number(taskRow.pick_mode || 0);
|
||
|
||
// 查询任务关联的所有波次
|
||
const taskWaveRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, box_no
|
||
FROM wms_wave_pick_task_wave
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
ORDER BY box_no ASC, wave_id ASC
|
||
`,
|
||
{
|
||
replacements: { taskId: normalizedTaskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskWaves = Array.isArray(taskWaveRows) ? taskWaveRows : [];
|
||
|
||
// 并行查询每个波次的详细信息和订单
|
||
const waveViewPromises = taskWaves.map(async tw => {
|
||
const twWaveId = Number(tw.wave_id || 0);
|
||
const twWaveNo = String(tw.wave_no || '').trim();
|
||
|
||
if (twWaveId <= 0) {
|
||
return null;
|
||
}
|
||
|
||
const waveView = await this.buildSingleWaveView(twWaveId, twWaveNo, warehouseId);
|
||
|
||
if (!waveView) {
|
||
return null;
|
||
}
|
||
|
||
// 分离拦截订单与非拦截订单
|
||
const orders = Array.isArray(waveView.orders) ? waveView.orders : [];
|
||
const interceptedOrders = [];
|
||
const normalOrders = [];
|
||
for (const order of orders) {
|
||
const interceptStatus = String(order.intercept_status || '').trim();
|
||
if (interceptStatus === 'intercepted') {
|
||
interceptedOrders.push(order);
|
||
} else {
|
||
normalOrders.push(order);
|
||
}
|
||
}
|
||
|
||
// 校验所有非拦截订单是否都已拣货/未被拦截,不允许复核
|
||
for (const order of normalOrders) {
|
||
this.assertOrderCanRecheck(order);
|
||
}
|
||
|
||
// 团购波次中所有订单商品一致,取第一个正常订单的商品明细作为样板
|
||
const sampleOrder = normalOrders.length > 0 ? normalOrders[0] : null;
|
||
const sampleStock = sampleOrder ? (Array.isArray(sampleOrder.stock) ? sampleOrder.stock : []) : [];
|
||
const stocks = sampleStock.map(item => ({
|
||
stock_id: Number(item.stock_id || 0),
|
||
item_code: String(item.item_code || '').trim(),
|
||
item_name: String(item.item_name || '').trim(),
|
||
sku_property: String(item.sku_property || '').trim(),
|
||
packing_requirements: String(item.packing_requirements || '').trim(),
|
||
barcodes: Array.isArray(item.barcodes) ? [ ...item.barcodes ] : [],
|
||
images: Array.isArray(item.images) ? [ ...item.images ] : [],
|
||
has_shared_barcode: Boolean(item.has_shared_barcode),
|
||
plan_qty: Number(item.plan_qty || 0),
|
||
}));
|
||
|
||
// 构建拦截订单列表
|
||
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;
|
||
}
|
||
|
||
// 团购波次内所有订单商品结构一致,暂存样本订单的商品指纹信息用于后续批量查询包材推荐
|
||
result._sample_hash = sampleOrder ? String(sampleOrder.items_hash || '').trim() : '';
|
||
result._sample_crc = sampleOrder ? Number(sampleOrder.items_crc || 0) : 0;
|
||
result.items_weight = sampleOrder ? Number(sampleOrder.items_weight || 0) : 0;
|
||
result.suggested_package_material = null;
|
||
|
||
// 波次内首个订单的运单号,用于包材绑定等后续操作
|
||
// 优先取首个正常订单的运单号,若无正常订单则取首个订单(含拦截)的运单号,均无则为空字符串
|
||
const firstNonIntercepted = normalOrders.length > 0 ? normalOrders[0] : null;
|
||
const firstAnyOrder = orders.length > 0 ? orders[0] : null;
|
||
const firstOrderForWaybill = firstNonIntercepted || firstAnyOrder;
|
||
result.first_waybill_no = firstOrderForWaybill
|
||
? String(firstOrderForWaybill.waybill_no || '').trim()
|
||
: '';
|
||
|
||
return result;
|
||
});
|
||
|
||
const waveViews = (await Promise.all(waveViewPromises)).filter(view => view !== null);
|
||
|
||
// 批量查询所有波次的包材推荐
|
||
if (waveViews.length > 0) {
|
||
const sampleOrdersForPackageQuery = waveViews
|
||
.filter(wv => wv._sample_hash)
|
||
.map(wv => ({ items_hash: wv._sample_hash, items_crc: wv._sample_crc }));
|
||
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(
|
||
sampleOrdersForPackageQuery,
|
||
warehouseId
|
||
);
|
||
for (const wv of waveViews) {
|
||
if (wv._sample_hash) {
|
||
wv.suggested_package_material = packageMaterialMap.get(wv._sample_hash) || null;
|
||
}
|
||
// 清理内部临时字段
|
||
delete wv._sample_hash;
|
||
delete wv._sample_crc;
|
||
}
|
||
}
|
||
|
||
return waveViews;
|
||
}
|
||
|
||
/**
|
||
* 通过波次ID查询关联的拣货模式。
|
||
* 优先查询 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联。
|
||
* @param {number} waveId 波次ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<number>} 拣货模式编码,未找到返回 0。
|
||
*/
|
||
async getPickModeByWaveId(waveId, warehouseId) {
|
||
const { ctx } = this;
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
|
||
if (normalizedWaveId <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
// 先按 wave_id 直接查拣货任务
|
||
const taskRows = await ctx.model.query(
|
||
`
|
||
SELECT pick_mode
|
||
FROM wms_wave_pick_task
|
||
WHERE wave_id = :waveId
|
||
AND warehouse_id = :warehouseId
|
||
ORDER BY create_time DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
if (Array.isArray(taskRows) && taskRows.length > 0) {
|
||
return Number(taskRows[0].pick_mode || 0);
|
||
}
|
||
|
||
// 通过 wms_wave_pick_task_wave 关联查询
|
||
const twRows = await ctx.model.query(
|
||
`
|
||
SELECT t.pick_mode
|
||
FROM wms_wave_pick_task_wave tw
|
||
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
|
||
WHERE tw.wave_id = :waveId
|
||
AND tw.warehouse_id = :warehouseId
|
||
ORDER BY t.create_time DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
if (Array.isArray(twRows) && twRows.length > 0) {
|
||
return Number(twRows[0].pick_mode || 0);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 根据波次ID查询关联的拣货任务ID。
|
||
* 优先查 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联表。
|
||
* @param {number} waveId 波次ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<number>} 拣货任务ID,未找到返回 0。
|
||
*/
|
||
async getTaskIdByWaveId(waveId, warehouseId) {
|
||
const { ctx } = this;
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
|
||
if (normalizedWaveId <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
// 先按 wave_id 直接查拣货任务
|
||
const taskRows = await ctx.model.query(
|
||
`
|
||
SELECT id AS task_id
|
||
FROM wms_wave_pick_task
|
||
WHERE wave_id = :waveId
|
||
AND warehouse_id = :warehouseId
|
||
ORDER BY create_time DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
if (Array.isArray(taskRows) && taskRows.length > 0) {
|
||
return Number(taskRows[0].task_id || 0);
|
||
}
|
||
|
||
// 通过 wms_wave_pick_task_wave 关联查询
|
||
const twRows = await ctx.model.query(
|
||
`
|
||
SELECT tw.task_id
|
||
FROM wms_wave_pick_task_wave tw
|
||
WHERE tw.wave_id = :waveId
|
||
AND tw.warehouse_id = :warehouseId
|
||
ORDER BY tw.task_id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
if (Array.isArray(twRows) && twRows.length > 0) {
|
||
return Number(twRows[0].task_id || 0);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 查询波次下所有订单的基本信息列表。
|
||
* 包含运单号、打印状态、复核状态、波次内序号(优先从 wms_order_wave_index 读取真实 wave_index,
|
||
* 若表无记录则降级使用 Array.map 临时序号),按未复核优先 + 波次内序号升序排序。
|
||
* @param {string} waveNo 波次号。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Array<Object>>} 订单基本信息列表,每项含 order_id、delivery_order_code、
|
||
* waybill_no、pick_status、is_printed、is_reviewed、shop_nick、items_count、
|
||
* wave_index、recheck_status、wave_id、wave_no、order_type、status、
|
||
* logistics_name、store_remark、intercept_status、items_weight、items_hash、items_crc、stock 等字段。
|
||
*/
|
||
async getWaveOrdersBasic(waveNo, warehouseId) {
|
||
const normalizedWaveNo = String(waveNo || '').trim();
|
||
|
||
if (!normalizedWaveNo) {
|
||
return [];
|
||
}
|
||
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
wave_no: normalizedWaveNo,
|
||
warehouse_id: warehouseId,
|
||
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
|
||
},
|
||
attributes: [
|
||
'id',
|
||
'delivery_order_code',
|
||
'pre_delivery_order_code',
|
||
'pick_status',
|
||
'wave_id',
|
||
'wave_no',
|
||
'order_type',
|
||
'status',
|
||
'recheck_status',
|
||
'items_count',
|
||
'shop_nick',
|
||
'logistics_name',
|
||
'print_status',
|
||
'store_id',
|
||
'intercept_status',
|
||
'items_weight',
|
||
'items_hash',
|
||
'items_crc',
|
||
],
|
||
order: [[ 'id', 'ASC' ]],
|
||
raw: true,
|
||
});
|
||
|
||
const { ctx } = this;
|
||
const orderRowsArray = Array.isArray(orderRows) ? orderRows : [];
|
||
const orderIds = orderRowsArray.map(row => Number(row.id || 0));
|
||
|
||
// 批量查询货主备注(wms_store_warehouse.store_remask)
|
||
const storeRemarkMap = new Map();
|
||
if (orderIds.length > 0 && ctx.model && ctx.model.StoreWarehouse) {
|
||
const storeIds = [
|
||
...new Set(
|
||
orderRowsArray
|
||
.map(row => Number(row.store_id || 0))
|
||
.filter(id => id > 0)
|
||
),
|
||
];
|
||
if (storeIds.length > 0) {
|
||
const swRows = await ctx.model.StoreWarehouse.findAll({
|
||
where: {
|
||
store_id: { [this.app.Sequelize.Op.in]: storeIds },
|
||
warehouse_id: warehouseId,
|
||
},
|
||
attributes: [ 'store_id', 'store_remask' ],
|
||
raw: true,
|
||
});
|
||
for (const sw of (Array.isArray(swRows) ? swRows : [])) {
|
||
const sid = Number(sw.store_id || 0);
|
||
if (sid > 0 && !storeRemarkMap.has(sid)) {
|
||
storeRemarkMap.set(sid, String(sw.store_remask || '').trim());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 批量查询运单信息
|
||
const waybillMap = new Map();
|
||
if (orderIds.length > 0 && ctx.model && ctx.model.OrderExpress) {
|
||
const expressRows = await ctx.model.OrderExpress.findAll({
|
||
where: { order_id: orderIds },
|
||
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(),
|
||
items_weight: Number(row.items_weight || 0),
|
||
items_hash: String(row.items_hash || '').trim(),
|
||
items_crc: Number(row.items_crc || 0),
|
||
};
|
||
});
|
||
|
||
// 排序:未复核的排前面,其次按波次内序号从小到大
|
||
orderList.sort((a, b) => {
|
||
const aReviewed = a.is_reviewed ? 1 : 0;
|
||
const bReviewed = b.is_reviewed ? 1 : 0;
|
||
if (aReviewed !== bReviewed) {
|
||
return aReviewed - bReviewed;
|
||
}
|
||
return a.wave_index - b.wave_index;
|
||
});
|
||
|
||
// 补充库存信息
|
||
const enrichedList = await this.enrichOrdersWithStock(orderList, warehouseId);
|
||
return enrichedList;
|
||
}
|
||
|
||
/**
|
||
* 批量查询包材推荐信息。
|
||
* 根据订单的 items_hash + items_crc 组合,从 wms_package_material_item_relation 表
|
||
* 查询最匹配的包材推荐(按 bind_count 降序取 top-1)。
|
||
* @param {Object[]} orderList 订单列表,每项需含 items_hash、items_crc 字段。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Map<string, Object|null>>} 以 items_hash 为键的包材推荐映射,
|
||
* 值为包材信息对象或 null(无推荐时)。
|
||
*/
|
||
async batchQueryPackageMaterialRecommendation(orderList, warehouseId) {
|
||
const resultMap = new Map();
|
||
|
||
if (!Array.isArray(orderList) || orderList.length === 0) {
|
||
return resultMap;
|
||
}
|
||
|
||
// 收集所有有效的 items_hash,并为每个 hash 记录对应的 items_crc
|
||
const hashCrcMap = new Map();
|
||
for (const order of orderList) {
|
||
const hash = String(order.items_hash || '').trim();
|
||
if (!hash) {
|
||
continue;
|
||
}
|
||
const crc = Number(order.items_crc || 0);
|
||
if (!hashCrcMap.has(hash)) {
|
||
hashCrcMap.set(hash, crc);
|
||
}
|
||
}
|
||
|
||
if (hashCrcMap.size === 0) {
|
||
return resultMap;
|
||
}
|
||
|
||
const uniqueHashes = [ ...hashCrcMap.keys() ];
|
||
const { ctx } = this;
|
||
|
||
if (!ctx.model || typeof ctx.model.query !== 'function') {
|
||
return resultMap;
|
||
}
|
||
|
||
// 批量查询所有匹配的包材绑定记录,按 bind_count 降序
|
||
let relationRows = [];
|
||
try {
|
||
relationRows = await ctx.model.query(
|
||
`SELECT * FROM wms_package_material_item_relation
|
||
WHERE warehouse_id = :warehouseId
|
||
AND items_hash IN (:uniqueHashes)
|
||
AND is_active = 1
|
||
AND delete_at IS NULL
|
||
ORDER BY bind_count DESC`,
|
||
{
|
||
replacements: { warehouseId, uniqueHashes },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
} catch (e) {
|
||
ctx.logger.warn(`[recheckOrder.batchQueryPackageMaterialRecommendation] 查询包材推荐失败, error=${e.message}`);
|
||
return resultMap;
|
||
}
|
||
|
||
const rows = Array.isArray(relationRows) ? relationRows : [];
|
||
|
||
// 为每个 items_hash 取第一条匹配记录(已按 bind_count DESC 排序,且 items_crc 匹配)
|
||
for (const row of rows) {
|
||
const hash = String(row.items_hash || '').trim();
|
||
if (!hash || resultMap.has(hash)) {
|
||
continue;
|
||
}
|
||
// 校验 items_crc 是否与订单一致
|
||
const expectedCrc = hashCrcMap.get(hash);
|
||
const rowCrc = Number(row.items_crc || 0);
|
||
if (expectedCrc !== undefined && expectedCrc !== rowCrc) {
|
||
continue;
|
||
}
|
||
resultMap.set(hash, {
|
||
id: row.id != null ? Number(row.id) : null,
|
||
code: String(row.package_material_code || '').trim() || null,
|
||
name: String(row.package_material_name || '').trim() || null,
|
||
spec: String(row.package_material_spec || '').trim() || null,
|
||
type: String(row.package_material_type || '').trim() || null,
|
||
weight: row.weight != null ? Number(row.weight) : null,
|
||
length: row.length != null ? Number(row.length) : null,
|
||
width: row.width != null ? Number(row.width) : null,
|
||
height: row.height != null ? Number(row.height) : null,
|
||
bind_count: row.bind_count != null ? Number(row.bind_count) : null,
|
||
});
|
||
}
|
||
|
||
return resultMap;
|
||
}
|
||
|
||
/**
|
||
* 为订单列表批量补充库存信息。
|
||
* 查询每个订单的明细商品、库存数量、条码列表和图片,构建 stock 数组。
|
||
* @param {Object[]} orderList 订单基本信息列表。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Object[]>} 补充了 stock 字段的订单列表。
|
||
*/
|
||
async enrichOrdersWithStock(orderList, warehouseId) {
|
||
if (!Array.isArray(orderList) || orderList.length === 0) {
|
||
return orderList;
|
||
}
|
||
|
||
const orderIds = orderList.map(o => Number(o.order_id || 0)).filter(Boolean);
|
||
if (orderIds.length === 0) {
|
||
return orderList;
|
||
}
|
||
|
||
// 1. 批量查询所有订单的商品明细
|
||
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
|
||
const allOrderItems = await orderItemsModel.findAll({
|
||
where: {
|
||
order_id: { [this.app.Sequelize.Op.in]: orderIds },
|
||
},
|
||
attributes: [ 'order_id', 'stock_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot' ],
|
||
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}`
|
||
);
|
||
}
|
||
|
||
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
|
||
const operatorName = String(operator.name || '').trim();
|
||
const taskStatusSetClauses = [
|
||
'status = 3',
|
||
'review_status = 3',
|
||
'review_finish_time = :now',
|
||
'review_time = :now',
|
||
'update_time = NOW()',
|
||
];
|
||
if (operatorUserId > 0) {
|
||
taskStatusSetClauses.push('review_user_id = :operatorUserId');
|
||
taskStatusSetClauses.push('review_user_name = :operatorName');
|
||
}
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET ${taskStatusSetClauses.join(',\n ')}
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { taskId, warehouseId, operatorUserId, operatorName, now },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
}
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 批量更新波次拣货任务订单的复核状态,并按任务维度检查是否需要解绑车任务。
|
||
* 与单订单版本不同,本方法一次性更新所有相关任务订单的 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}`
|
||
);
|
||
}
|
||
|
||
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
|
||
const operatorName = String(operator.name || '').trim();
|
||
const taskStatusSetClauses = [
|
||
'status = 3',
|
||
'review_status = 3',
|
||
'review_finish_time = :now',
|
||
'review_time = :now',
|
||
'update_time = NOW()',
|
||
];
|
||
if (operatorUserId > 0) {
|
||
taskStatusSetClauses.push('review_user_id = :operatorUserId');
|
||
taskStatusSetClauses.push('review_user_name = :operatorName');
|
||
}
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET ${taskStatusSetClauses.join(',\n ')}
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { taskId, warehouseId, operatorUserId, operatorName, now },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
}
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
|
||
* @param {number} taskId 波次拣货任务ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {number} operatorUserId 操作员用户ID。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async unbindCartForTask(taskId, warehouseId, operatorUserId) {
|
||
const { ctx } = this;
|
||
|
||
// 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('订单未拣货,不允许复核。');
|
||
}
|
||
const interceptStatus = String(order.intercept_status || '').trim();
|
||
if (interceptStatus === 'intercepted' || interceptStatus === 'intercepted_at_warehouse') {
|
||
throw new Error('订单已被拦截,无法提交复核');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 复核订单列表查询,通过入参 list_type 区分散单模式与团购模式。
|
||
* - 散单模式(single):返回待复核订单列表,每项为一个订单。
|
||
* - 团购模式(group):返回波次维度的复核列表,每项为一个波次及其订单汇总。
|
||
* 统一使用 list 字段名输出。
|
||
* @param {Object} data 请求参数。
|
||
* @param {string} [data.list_type='single'] 列表模式:single(散单模式)/ group(团购模式)。
|
||
* @param {Object} [data.where] 筛选条件。
|
||
* @param {Object} [data.pagination] 分页参数,兼容 page/pageSize。
|
||
* @return {Promise<Object>} 列表结果,包含 list 与 pagination。
|
||
*/
|
||
async recheckOrderList(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { list_type: listType = 'single' } = requestData;
|
||
const normalizedListType = String(listType || 'single').trim();
|
||
|
||
if (normalizedListType === 'group') {
|
||
return await this.queryRecheckOrderGroupList(requestData);
|
||
}
|
||
return await this.queryRecheckOrderSingleList(requestData);
|
||
}
|
||
|
||
/**
|
||
* 散单模式复核列表:按订单维度返回待复核订单,支持分页与关键词/波次号/复核状态筛选。
|
||
* @param {Object} data 请求参数。
|
||
* @param {Object} [data.where] 筛选条件,支持 keyword / wave_no / recheck_status / pick_status 等。
|
||
* @param {Object} [data.pagination] 分页参数。
|
||
* @return {Promise<Object>} { list: Array<Object>, pagination: Object }。
|
||
*/
|
||
async queryRecheckOrderSingleList(data = {}) {
|
||
const { ctx } = this;
|
||
const warehouseId = this.getWarehouseId();
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { page, pageSize } = this.normalizePagination(requestData.pagination || requestData);
|
||
const where = this.isPlainObject(requestData.where) ? requestData.where : {};
|
||
const offset = (page - 1) * pageSize;
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const orderTableName = this.resolveModelTableName(orderModel);
|
||
|
||
const conditions = [];
|
||
const replacements = { warehouseId, limit: pageSize, offset };
|
||
|
||
conditions.push('o.warehouse_id = :warehouseId');
|
||
conditions.push('o.pick_status != \'none\'');
|
||
conditions.push('o.recheck_status != \'fin\'');
|
||
|
||
// 关键词搜索:运单号 / 订单号
|
||
const keyword = String(where.keyword || '').trim();
|
||
if (keyword) {
|
||
conditions.push(`(
|
||
o.delivery_order_code LIKE :keyword
|
||
OR o.pre_delivery_order_code LIKE :keyword
|
||
OR EXISTS (
|
||
SELECT 1 FROM order_express oe
|
||
WHERE oe.order_id = o.id
|
||
AND oe.waybill_code LIKE :keyword
|
||
AND oe.delete_at IS NULL
|
||
)
|
||
)`);
|
||
replacements.keyword = `%${keyword}%`;
|
||
}
|
||
|
||
// 波次号筛选
|
||
const waveNo = String(where.wave_no || '').trim();
|
||
if (waveNo) {
|
||
conditions.push('o.wave_no = :waveNo');
|
||
replacements.waveNo = waveNo;
|
||
}
|
||
|
||
// 复核状态筛选
|
||
const recheckStatus = String(where.recheck_status || '').trim();
|
||
if (recheckStatus) {
|
||
conditions.push('o.recheck_status = :recheckStatus');
|
||
replacements.recheckStatus = recheckStatus;
|
||
}
|
||
|
||
// 拣货状态筛选
|
||
const pickStatus = String(where.pick_status || '').trim();
|
||
if (pickStatus) {
|
||
conditions.push('o.pick_status = :pickStatus');
|
||
replacements.pickStatus = pickStatus;
|
||
}
|
||
|
||
const whereClause = conditions.length > 0
|
||
? `WHERE ${conditions.join('\n AND ')}`
|
||
: '';
|
||
|
||
const listSql = `
|
||
SELECT
|
||
o.id AS order_id,
|
||
o.delivery_order_code,
|
||
o.pre_delivery_order_code,
|
||
o.order_type,
|
||
o.wave_id,
|
||
o.wave_no,
|
||
o.pick_status,
|
||
o.recheck_status,
|
||
o.shop_nick,
|
||
o.logistics_name,
|
||
o.items_count,
|
||
o.items_total,
|
||
o.items_weight,
|
||
o.weight_type,
|
||
o.status,
|
||
o.create_at,
|
||
o.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),
|
||
items_weight: row?.items_weight != null ? Number(row.items_weight) : null,
|
||
weight_type: this.formatWeightTypeLabel(row?.weight_type),
|
||
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('拦截状态更新失败,请稍后重试');
|
||
}
|
||
|
||
// 拦截成功后释放储位分配(归还库存)
|
||
try {
|
||
await this.service.systems.orderStorageAllocation.cancelAllocateStorage({
|
||
order_ids: [ orderId ],
|
||
});
|
||
} catch (allocErr) {
|
||
ctx.logger.warn(
|
||
`[recheckOrder.confirmIntercept] 释放储位分配失败,不影响拦截, orderId=${orderId}, error=${allocErr.message}`
|
||
);
|
||
}
|
||
|
||
// 拦截成功后释放订单锁
|
||
try {
|
||
await orderModel.update(
|
||
{ lock_status: 'none', updated_at: now },
|
||
{ where: orderWhere }
|
||
);
|
||
} catch (lockErr) {
|
||
ctx.logger.warn(
|
||
`[recheckOrder.confirmIntercept] 释放锁失败,不影响拦截, orderId=${orderId}, error=${lockErr.message}`
|
||
);
|
||
}
|
||
|
||
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
|
||
|
||
// 写入操作日志(失败不影响主流程)
|
||
try {
|
||
const operator = this.getOrderLogOperator();
|
||
const logWarehouseId = this.getOrderLogWarehouseId(warehouseId);
|
||
await ctx.service.systems.operationLog.createOperationLog({
|
||
businessType: 'order',
|
||
businessId: logWarehouseId,
|
||
operationCode: 'ORDER_INTERCEPT_CONFIRM',
|
||
operator,
|
||
extras: {
|
||
warehouseId: logWarehouseId,
|
||
orderId,
|
||
orderNo,
|
||
previousInterceptStatus: String(order.intercept_status || '').trim(),
|
||
newInterceptStatus: 'intercepted_at_warehouse',
|
||
},
|
||
beforeChanges: null,
|
||
});
|
||
} catch (logErr) {
|
||
ctx.logger.warn(
|
||
`[recheckOrder.confirmIntercept] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${logErr.message}`
|
||
);
|
||
}
|
||
|
||
return {
|
||
order_id: orderId,
|
||
order_no: orderNo,
|
||
intercept_status: 'intercepted_at_warehouse',
|
||
updated_at: now,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 批量快捷复核:对一批订单 IDs 依次执行前置条件检查与复核流程。
|
||
* 支持部分失败:不满足前置条件的订单直接跳过并记录失败原因,其余订单继续走完拣货完成 + 复核标记流程。
|
||
*
|
||
* 前置条件(任一不满足即跳过):
|
||
* 1. 未分配储位:storage_status 不等于 'fin'
|
||
* 2. 未分配快递:post_status 不等于 'fin'
|
||
* 3. 未同步:status 不等于 'created'
|
||
* 4. 已拦截:intercept_status 为 'intercepted' 或 'intercepted_at_warehouse'
|
||
*
|
||
* 核心流程(每个满足条件的订单在独立事务中执行):
|
||
* 1. 若 pick_status 不等于 'fin',先完成拣货:
|
||
* - 更新 wms_wave_pick_task_order 拣货状态(仅当订单关联拣货任务时)
|
||
* - 更新 wms_order_delivery.pick_status = 'fin'
|
||
* - 更新 wms_picking.status = 'fin'(仅当存在拣货记录时)
|
||
* - 汇总 wms_picking 中各 storage_id 的 quantity,扣减 wms_storage.locked_quantity 与 quantity
|
||
* - 写入 wms_storage_transaction 出库流水
|
||
* 2. 标记复核:
|
||
* - 更新 wms_order_delivery.recheck_status = 'fin'、recheck_time = now
|
||
* - 插入 wms_recheck_task 复核记录
|
||
* - 更新 wms_wave_pick_task_order 复核状态并尝试解绑车任务
|
||
* - 写入操作日志
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @param {number[]|string} data.ids 订单 ID 列表,支持数组或以逗号分隔的字符串。
|
||
* @return {Promise<Object>} 批量复核结果,包含 success、failed、success_count、failed_count。
|
||
*/
|
||
async batchQuickRecheck(data = {}) {
|
||
const { ctx } = this;
|
||
const warehouseId = this.getWarehouseId();
|
||
const orderIds = this.normalizeOrderIds(data);
|
||
|
||
if (orderIds.length === 0) {
|
||
this.ctx.throw(400, '订单ID列表不能为空');
|
||
}
|
||
|
||
// ── 1. 批量查询所有订单的当前状态 ──
|
||
const orderModel = await this.getOrderModel('order', warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
where: this.buildOrderWhere(orderIds, warehouseId),
|
||
attributes: [
|
||
'id', 'delivery_order_code', 'pre_delivery_order_code',
|
||
'storage_status', 'post_status', 'status', 'intercept_status',
|
||
'pick_status', 'recheck_status', 'wave_id', 'wave_no',
|
||
],
|
||
raw: true,
|
||
});
|
||
|
||
const orderMap = new Map();
|
||
for (const row of orderRows) {
|
||
orderMap.set(Number(row.id), row);
|
||
}
|
||
|
||
// ── 2. 前置条件检查:将订单分为有效订单与跳过订单 ──
|
||
const validOrders = [];
|
||
const failedOrders = [];
|
||
|
||
for (const orderId of orderIds) {
|
||
const order = orderMap.get(orderId);
|
||
|
||
if (!order) {
|
||
failedOrders.push({ order_id: orderId, reason: '未找到对应订单' });
|
||
continue;
|
||
}
|
||
|
||
const interceptStatus = String(order.intercept_status || '').trim();
|
||
if (interceptStatus === 'intercepted' || interceptStatus === 'intercepted_at_warehouse') {
|
||
failedOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
reason: '已拦截',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const storageStatus = String(order.storage_status || '').trim();
|
||
if (storageStatus !== 'fin') {
|
||
failedOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
reason: '未分配储位',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const postStatus = String(order.post_status || '').trim();
|
||
if (postStatus !== 'fin') {
|
||
failedOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
reason: '没有分配快递',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const orderStatus = String(order.status || '').trim();
|
||
if (orderStatus !== 'created') {
|
||
failedOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
reason: '没有同步',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
validOrders.push(order);
|
||
}
|
||
|
||
// ── 3. 逐订单在独立事务中执行拣货完成 + 复核标记 ──
|
||
const successOrders = [];
|
||
|
||
for (const order of validOrders) {
|
||
const orderId = Number(order.id);
|
||
|
||
try {
|
||
await ctx.model.transaction(async transaction => {
|
||
// 3a. 若未完成拣货,先执行拣货完成流程
|
||
const pickStatus = String(order.pick_status || '').trim();
|
||
if (pickStatus !== 'fin') {
|
||
await this._completePickForOrder(orderId, warehouseId, transaction);
|
||
// 更新内存中的 pick_status,避免后续 assertOrderCanRecheck 因旧值误判
|
||
order.pick_status = 'fin';
|
||
}
|
||
|
||
// 3b. 标记复核
|
||
await this._markRecheckForOrder(order, warehouseId, transaction);
|
||
});
|
||
|
||
successOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
});
|
||
} catch (error) {
|
||
ctx.logger.warn(
|
||
`[batchQuickRecheck] 订单复核失败, orderId=${orderId}, error=${error.message}`
|
||
);
|
||
failedOrders.push({
|
||
order_id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
|
||
reason: `复核失败: ${error.message}`,
|
||
});
|
||
}
|
||
}
|
||
|
||
return {
|
||
success: successOrders,
|
||
failed: failedOrders,
|
||
success_count: successOrders.length,
|
||
failed_count: failedOrders.length,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 完成单个订单的拣货流程(内部方法,在事务中执行)。
|
||
* 包含:更新拣货任务订单状态、订单拣货状态、拣货记录状态、扣减库存锁定数量与可用数量、写库存流水。
|
||
*
|
||
* @param {number} orderId 订单ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {Object} transaction Sequelize 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async _completePickForOrder(orderId, warehouseId, transaction) {
|
||
const { ctx, app } = this;
|
||
|
||
// 步骤1:若订单关联拣货任务,更新 wms_wave_pick_task_order 的拣货状态
|
||
const taskOrderRows = await ctx.model.query(
|
||
`SELECT id, task_id
|
||
FROM wms_wave_pick_task_order
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { orderId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const hasTaskOrder = Array.isArray(taskOrderRows) && taskOrderRows.length > 0;
|
||
|
||
if (hasTaskOrder) {
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task_order
|
||
SET pick_status = 1,
|
||
picked_time = NOW(),
|
||
update_time = NOW()
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { orderId, warehouseId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
|
||
// 步骤2:更新 wms_order_delivery.pick_status = 'fin'
|
||
const orderModel = await this.getOrderModel('order', warehouseId);
|
||
await orderModel.update(
|
||
{ pick_status: 'fin' },
|
||
{
|
||
where: this.buildOrderWhere([ orderId ], warehouseId),
|
||
transaction,
|
||
validate: false,
|
||
hooks: false,
|
||
}
|
||
);
|
||
|
||
// 步骤3:检查是否存在 wms_picking 记录
|
||
const pickingRows = await ctx.model.query(
|
||
`SELECT id, storage_id, quantity, space_id
|
||
FROM wms_picking
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { orderId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
|
||
|
||
if (normalizedPickingRows.length > 0) {
|
||
// 更新 wms_picking.status = 'fin'
|
||
await ctx.model.query(
|
||
`UPDATE wms_picking
|
||
SET status = 'fin', updated_at = NOW()
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { orderId, warehouseId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 步骤4:汇总各 storage_id 的 quantity,扣减 wms_storage 锁定数量与可用数量
|
||
const storageQtyMap = new Map();
|
||
for (const row of normalizedPickingRows) {
|
||
const sid = Number(row.storage_id);
|
||
if (!sid || sid <= 0) continue;
|
||
const currentQty = storageQtyMap.get(sid) || 0;
|
||
storageQtyMap.set(sid, currentQty + (Number(row.quantity) || 0));
|
||
}
|
||
|
||
const storageIds = Array.from(storageQtyMap.keys());
|
||
if (storageIds.length > 0) {
|
||
// 加行锁查询当前库存
|
||
const storageRows = await ctx.model.Storage.findAll({
|
||
where: {
|
||
id: { [app.Sequelize.Op.in]: storageIds },
|
||
warehouse_id: warehouseId,
|
||
},
|
||
attributes: [
|
||
'id', 'locked_quantity', 'quantity',
|
||
'store_id', 'stock_id', 'batch_no', 'inventory_type', 'space_id',
|
||
],
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
// 校验锁定数量是否足够
|
||
for (const sRow of storageRows) {
|
||
const sid = Number(sRow.id);
|
||
const deduction = storageQtyMap.get(sid) || 0;
|
||
const locked = Number(sRow.locked_quantity) || 0;
|
||
if (locked < deduction) {
|
||
throw new Error(
|
||
`库存记录 ${sid} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`
|
||
);
|
||
}
|
||
}
|
||
|
||
// 构建 CASE WHEN 批量扣减
|
||
const summaryEntries = Array.from(storageQtyMap.entries());
|
||
const caseClauses = summaryEntries
|
||
.map(([ sid, qty ]) => `WHEN ${sid} THEN ${qty}`)
|
||
.join(' ');
|
||
|
||
await ctx.model.query(
|
||
`UPDATE wms_storage
|
||
SET locked_quantity = locked_quantity - CASE id ${caseClauses} END,
|
||
quantity = quantity - CASE id ${caseClauses} END,
|
||
updated_at = NOW()
|
||
WHERE id IN (:storageIds)
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { storageIds, warehouseId },
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 写入 wms_storage_transaction 出库流水
|
||
const operator = this.getOrderLogOperator();
|
||
const operatorId = String(operator.id || '').trim();
|
||
const operatorName = String(operator.name || 'system').trim();
|
||
const transactionRows = [];
|
||
|
||
for (const sRow of storageRows) {
|
||
const sid = Number(sRow.id);
|
||
const deduction = storageQtyMap.get(sid) || 0;
|
||
if (deduction <= 0) continue;
|
||
const beforeQty = Number(sRow.quantity) || 0;
|
||
const beforeLocked = Number(sRow.locked_quantity) || 0;
|
||
transactionRows.push({
|
||
transaction_type: 'OUTBOUND',
|
||
warehouse_id: warehouseId,
|
||
store_id: Number(sRow.store_id) || 0,
|
||
stock_id: Number(sRow.stock_id) || 0,
|
||
storage_id: sid,
|
||
space_id: Number(sRow.space_id) || null,
|
||
quantity: deduction,
|
||
before_quantity: beforeQty,
|
||
after_quantity: Math.max(0, beforeQty - deduction),
|
||
before_locked_quantity: beforeLocked,
|
||
after_locked_quantity: Math.max(0, beforeLocked - deduction),
|
||
batch_no: sRow.batch_no || null,
|
||
inventory_type: sRow.inventory_type || 'ZP',
|
||
order_type: 'PICK_OUTBOUND',
|
||
order_no: String(orderId),
|
||
order_id: orderId,
|
||
source_order_codes: String(orderId),
|
||
operator_id: operatorId,
|
||
operator_name: operatorName,
|
||
remark: '拣货完成出库(批量快捷复核)',
|
||
created_at: new Date(),
|
||
});
|
||
}
|
||
|
||
if (transactionRows.length > 0) {
|
||
await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction });
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
// 步骤5:更新 wms_wave_pick_task 状态
|
||
if (hasTaskOrder) {
|
||
const taskId = Number(taskOrderRows[0]?.task_id || 0);
|
||
if (taskId > 0) {
|
||
// 检查该任务下是否所有订单都已完成拣货
|
||
const taskOrderCount = await ctx.model.query(
|
||
`SELECT COUNT(*) AS cnt
|
||
FROM wms_wave_pick_task_order
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
AND pick_status != 1`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
const allPicked = (Number(taskOrderCount[0]?.cnt || 0)) === 0;
|
||
|
||
if (allPicked) {
|
||
// 全部完成 → 任务状态设为已完成
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET status = 2,
|
||
finish_time = NOW(),
|
||
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
|
||
update_time = NOW()
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
} else {
|
||
// 未全部完成 → 任务状态推进为拣货中(若仍为未开始)
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET status = CASE WHEN status = 0 THEN 1 ELSE status END,
|
||
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
|
||
update_time = NOW()
|
||
WHERE id = :taskId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 标记单个订单为已复核(内部方法,在事务中执行)。
|
||
* 包含:更新订单复核状态、插入复核任务记录、更新拣货任务复核状态并尝试解绑车任务、写操作日志。
|
||
*
|
||
* @param {Object} order 订单信息行。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {Object} transaction Sequelize 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async _markRecheckForOrder(order, warehouseId, transaction) {
|
||
const { ctx } = this;
|
||
const orderId = Number(order.id);
|
||
|
||
// 校验订单是否允许复核(拣货已完成且未被拦截)
|
||
this.assertOrderCanRecheck(order);
|
||
|
||
const now = new Date();
|
||
|
||
// 更新订单复核状态
|
||
const orderModel = await this.getOrderModel('order', warehouseId);
|
||
await orderModel.update(
|
||
{
|
||
recheck_status: 'fin',
|
||
recheck_time: now,
|
||
updated_at: now,
|
||
},
|
||
{
|
||
where: this.buildOrderWhere([ orderId ], warehouseId),
|
||
transaction,
|
||
validate: false,
|
||
hooks: false,
|
||
}
|
||
);
|
||
|
||
// 插入 wms_recheck_task 复核记录
|
||
const operator = this.getOrderLogOperator();
|
||
const reviewNo = this.buildRecheckReviewNo(orderId, now);
|
||
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
|
||
const operatorNo = String(operator.id || '').trim();
|
||
const operatorName = String(operator.name || '').trim();
|
||
|
||
await ctx.model.query(
|
||
`INSERT INTO wms_recheck_task (
|
||
review_no,
|
||
warehouse_id,
|
||
order_id,
|
||
order_no,
|
||
waybill_no,
|
||
task_status,
|
||
scan_status,
|
||
review_emp_no,
|
||
review_emp_name,
|
||
scan_emp_no,
|
||
scan_emp_name,
|
||
scan_time,
|
||
finish_time,
|
||
remark
|
||
) VALUES (
|
||
:reviewNo,
|
||
:warehouseId,
|
||
:orderId,
|
||
:orderNo,
|
||
:waybillNo,
|
||
:taskStatus,
|
||
:scanStatus,
|
||
:reviewEmpNo,
|
||
:reviewEmpName,
|
||
:scanEmpNo,
|
||
:scanEmpName,
|
||
:scanTime,
|
||
:finishTime,
|
||
:remark
|
||
)`,
|
||
{
|
||
replacements: {
|
||
reviewNo,
|
||
warehouseId,
|
||
orderId,
|
||
orderNo,
|
||
waybillNo: '',
|
||
taskStatus: 2,
|
||
scanStatus: 1,
|
||
reviewEmpNo: operatorNo,
|
||
reviewEmpName: operatorName,
|
||
scanEmpNo: operatorNo,
|
||
scanEmpName: operatorName,
|
||
scanTime: now,
|
||
finishTime: now,
|
||
remark: '系统复核完成(批量快捷复核)',
|
||
},
|
||
type: ctx.model.QueryTypes.INSERT,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务
|
||
await this._updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction);
|
||
|
||
// 写入操作日志
|
||
await this._writeRecheckActionLogInTransaction({
|
||
orderId,
|
||
warehouseId,
|
||
operator,
|
||
now,
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 在事务中更新波次拣货任务订单的复核状态,并判断是否需要解绑车任务。
|
||
*
|
||
* @param {number} orderId 订单ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {{ id: string|null, name: string }} operator 操作人信息。
|
||
* @param {Date} now 当前时间。
|
||
* @param {Object} transaction Sequelize 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async _updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction) {
|
||
const { ctx } = this;
|
||
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
|
||
const hasReviewStatus = taskOrderColumnSet.has('review_status');
|
||
|
||
if (!hasReviewStatus) {
|
||
return;
|
||
}
|
||
|
||
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
|
||
const hasReviewResult = taskOrderColumnSet.has('review_result');
|
||
const hasReviewTime = taskOrderColumnSet.has('review_time');
|
||
const operatorUserId = Number(operator.id) || 0;
|
||
|
||
const reviewSetClauses = [ 'review_status = 1' ];
|
||
|
||
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
|
||
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
|
||
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
|
||
reviewSetClauses.push('update_time = NOW()');
|
||
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task_order
|
||
SET ${reviewSetClauses.join(',\n ')}
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: {
|
||
orderId,
|
||
warehouseId,
|
||
operatorUserId,
|
||
now,
|
||
},
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 查询当前订单所属的波次拣货任务ID
|
||
const taskRows = await ctx.model.query(
|
||
`SELECT DISTINCT task_id
|
||
FROM wms_wave_pick_task_order
|
||
WHERE order_id = :orderId
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { orderId, warehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const taskId = Number(
|
||
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
|
||
);
|
||
|
||
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,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const unreviewedCount = Number(
|
||
(Array.isArray(unreviewedRows) && unreviewedRows.length > 0 ? unreviewedRows[0]?.cnt : 0)
|
||
);
|
||
|
||
if (unreviewedCount > 0) {
|
||
return;
|
||
}
|
||
|
||
// 任务下所有订单均已复核完成,解绑车任务
|
||
try {
|
||
await this._unbindCartForTaskInTransaction(taskId, warehouseId, operatorUserId, transaction);
|
||
ctx.logger.info(
|
||
`[batchQuickRecheck] 车任务解绑成功, taskId=${taskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
|
||
);
|
||
} catch (unbindError) {
|
||
ctx.logger.warn(
|
||
`[batchQuickRecheck] 解绑车任务失败(复核已成功), taskId=${taskId}, orderId=${orderId}, error=${unbindError.message}`
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 在事务中解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
|
||
*
|
||
* @param {number} taskId 波次拣货任务ID。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {number} operatorUserId 操作员用户ID。
|
||
* @param {Object} transaction Sequelize 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async _unbindCartForTaskInTransaction(taskId, warehouseId, operatorUserId, transaction) {
|
||
const { ctx } = this;
|
||
|
||
// 清空波次拣货任务的车绑定信息
|
||
await ctx.model.query(
|
||
`UPDATE wms_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,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 停用拣货车绑定记录
|
||
await ctx.model.query(
|
||
`UPDATE wms_pick_task_cart_binding
|
||
SET is_active = 0,
|
||
unbind_user_id = :operatorUserId,
|
||
unbind_time = NOW(),
|
||
update_time = NOW()
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
AND is_active = 1`,
|
||
{
|
||
replacements: { taskId, warehouseId, operatorUserId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 释放拣货车
|
||
await ctx.model.query(
|
||
`UPDATE wms_pick_cart
|
||
SET status = 'idle',
|
||
current_task_id = NULL,
|
||
update_time = NOW()
|
||
WHERE id IN (
|
||
SELECT cart_id
|
||
FROM wms_pick_task_cart_binding
|
||
WHERE task_id = :taskId
|
||
AND warehouse_id = :warehouseId
|
||
)
|
||
AND warehouse_id = :warehouseId`,
|
||
{
|
||
replacements: { taskId, warehouseId },
|
||
type: ctx.model.QueryTypes.UPDATE,
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 在事务中写入复核操作日志(内部方法)。
|
||
*
|
||
* @param {Object} params 日志参数。
|
||
* @param {number} params.orderId 订单ID。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
|
||
* @param {Date} params.now 操作时间。
|
||
* @param {Object} params.transaction Sequelize 事务对象。
|
||
* @return {Promise<void>} 无返回值。
|
||
*/
|
||
async _writeRecheckActionLogInTransaction(params = {}) {
|
||
const { orderId, warehouseId, operator, now, transaction } = params;
|
||
const operatorId = operator && operator.id ? Number(operator.id) : 0;
|
||
const operatorName = operator && operator.name ? String(operator.name).trim() : 'system';
|
||
const requestId = `recheck_${warehouseId}_${orderId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
|
||
|
||
await this.ctx.model.query(
|
||
`INSERT INTO wms_wave_pick_action_log (
|
||
task_id,
|
||
warehouse_id,
|
||
wave_id,
|
||
order_id,
|
||
sku_id,
|
||
location_id,
|
||
box_no,
|
||
cart_id,
|
||
qty_delta,
|
||
action_type,
|
||
request_id,
|
||
operator_id,
|
||
device_id,
|
||
seq_no,
|
||
snapshot
|
||
) VALUES (
|
||
:taskId,
|
||
:warehouseId,
|
||
:waveId,
|
||
:orderId,
|
||
:skuId,
|
||
:locationId,
|
||
:boxNo,
|
||
:cartId,
|
||
:qtyDelta,
|
||
:actionType,
|
||
:requestId,
|
||
:operatorId,
|
||
:deviceId,
|
||
:seqNo,
|
||
:snapshot
|
||
)`,
|
||
{
|
||
replacements: {
|
||
taskId: 0,
|
||
warehouseId: warehouseId || 0,
|
||
waveId: null,
|
||
orderId: orderId || 0,
|
||
skuId: null,
|
||
locationId: null,
|
||
boxNo: null,
|
||
cartId: null,
|
||
qtyDelta: 0,
|
||
actionType: 'recheck',
|
||
requestId,
|
||
operatorId,
|
||
deviceId: null,
|
||
seqNo: 1,
|
||
snapshot: JSON.stringify({
|
||
order_id: orderId,
|
||
operator_name: operatorName,
|
||
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
|
||
}),
|
||
},
|
||
type: this.ctx.model.QueryTypes.INSERT,
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
|
||
}
|
||
|
||
module.exports = RecheckOrderService;
|