liufumingren 9af7dcf8fb feat(storeWarehouse): 签约关系接口配置按货主开放接口落库且回调地址统一取配置
- storeWarehouse.store.saveApiConfig:新增 resolveContractApiInterfaceType,
  interface_type_id=3(OPEN_API_WAREHOUSE 仓库开放接口)自动映射为 2(OPEN_API 货主开放接口)落库,
  不再要求当前主体为仓库(货主可维护自身签约关系下的接口配置)
- callback_url 不再取入参(含 callbackUrl 别名),统一写入 config.openapi.defaultCallbackUrl(新增配置项,默认空)
- storeWarehouse.store.listApiConfig:interface_type_id 过滤同步映射(传 3 按 2 查询)
- 文档:methods/system.json 升级 0.3.350、methods/changes/system.json 变更记录、docs/openapi-callback-events.md 回调地址来源说明
- 测试:saveApiConfig 新增 4 条用例(3→2 落库、忽略入参回调地址、默认值未配置、货主主体可保存、缺失类型 404),listApiConfig 新增 1 条过滤映射用例

同时提交工作区其余在制品改动:
- waybill:移除 wms_order_express_trace 模型并新增 drop 迁移,轨迹查询/取号/打印链路调整
- order:订单 SN 编码(order_item_sn / order_item_sn_log / sn_code_rule、has_sn_item 回填迁移),pendingOrder/recheckOrder/wave/base 调整
- express_platform、order_async、order_export、order_storage_allocation、storage.report、stock_store 配套修复
- lib:新增 jd_client,调整 qimen_client、callback_functions 及配套测试

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-14 17:14:04 +08:00

5684 lines
204 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const OrderBaseService = require('./base');
class RecheckOrderService extends OrderBaseService {
/**
* 初始化复核订单系统方法免登录、免权限、免日志与免鉴权配置。
* @param {Egg.Context} ctx 请求上下文。
*/
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave,queryRecheckOrderSingleList,interceptScan';
const _noNeedLog = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave,interceptScan';
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,batchQuickRecheckByWave,queryRecheckOrderSingleList,interceptScan';
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)
* - 任一模式首次成功加载波次复核视图时,回写该波次的复核开始时间(recheck_start_time),
* 仅首次写入(按 IS 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),
]);
await this.markWaveRecheckStart(
groupWaveList.map(item => Number(item.wave_id || 0)),
warehouseId
);
return {
match_type: matchType,
list_type: 'group',
waybill_no: keyword,
wave_id: orderWaveId,
picker_id: pickerInfo.picker_id,
picker_name: pickerInfo.picker_name,
task_id: groupTaskId,
list: groupWaveList,
};
}
// 找不到拣货任务时退回单订单详情模式
this.assertOrderCanRecheck(order);
const detailResult = await this.detail({ id: orderId });
const fallbackOrder = detailResult.detail || {};
const fallbackPackageMap = await this.batchQueryPackageMaterialRecommendation(
[{ items_hash: fallbackOrder.items_hash, items_crc: fallbackOrder.items_crc }],
warehouseId
);
const fallbackItemHash = String(fallbackOrder.items_hash || '').trim();
return {
match_type: matchType,
list_type: 'single',
waybill_no: keyword,
list: [{
...fallbackOrder,
items: Array.isArray(detailResult.items) ? detailResult.items : [],
expresses: Array.isArray(detailResult.expresses) ? detailResult.expresses : [],
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
suggested_package_material: fallbackItemHash
? (fallbackPackageMap.get(fallbackItemHash) || null)
: null,
}],
};
}
const scanView = await this.buildSingleWaveScanView(orderWaveId, orderWaveNo, warehouseId);
if (scanView) {
await this.markWaveRecheckStart([ orderWaveId ], warehouseId);
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),
]);
await this.markWaveRecheckStart(
groupWaveList.map(item => Number(item.wave_id || 0)),
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) {
await this.markWaveRecheckStart([ waveId ], warehouseId);
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),
]);
await this.markWaveRecheckStart(
groupWaveList.map(item => Number(item.wave_id || 0)),
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 = [];
const scannedWaveIds = [];
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);
scannedWaveIds.push(waveId);
}
}
}
// 扫描视图构建成功后回写波次复核开始时间(仅首次写入,失败不影响主流程)
await this.markWaveRecheckStart(scannedWaveIds, warehouseId);
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;
// 复核统计仅计非拦截订单(拦截订单保留在 list 中按单提示)
const reviewableOrders = mergedList.filter(
o => !this.isInterceptedOrderStatus(o.intercept_status)
);
const reviewedCount = reviewableOrders.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = reviewableOrders.length - 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('未找到对应订单');
}
/**
* 回写波次复核开始时间(仅首次扫描写入)。
* 对每个有效波次执行条件更新:仅当 recheck_start_time 为空时写入 NOW(),并同步刷新 update_time,
* 与拣货任务开始时间补写惯例(app/service/systems/pick.js)保持一致;
* 多波次场景每个波次各自按 IS NULL 条件判断,已写过复核开始时间的波次不会被覆盖。
* 回写失败仅记录告警日志,不阻断扫描主流程(如迁移未执行导致字段缺失等场景)。
* @param {number|Array<number>} waveIds 波次ID或波次ID数组。
* @param {number} warehouseId 仓库ID。
* @return {Promise<void>} 无返回值。
*/
async markWaveRecheckStart(waveIds, warehouseId) {
const { ctx } = this;
const normalizedWarehouseId = Number(warehouseId || 0);
const sourceWaveIds = Array.isArray(waveIds) ? waveIds : [ waveIds ];
const normalizedWaveIds = [ ...new Set(sourceWaveIds
.map(id => Number(id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
if (normalizedWarehouseId <= 0 || normalizedWaveIds.length === 0) {
return;
}
try {
await ctx.model.query(
`
UPDATE wms_wave_batch
SET recheck_start_time = NOW(),
update_time = NOW()
WHERE wave_id IN (:waveIds)
AND warehouse_id = :warehouseId
AND recheck_start_time IS NULL
`,
{
replacements: { waveIds: normalizedWaveIds, warehouseId: normalizedWarehouseId },
}
);
} catch (error) {
ctx.logger.warn(
`[recheckOrder.markWaveRecheckStart] 回写波次复核开始时间失败,不影响扫描主流程, waveIds=${normalizedWaveIds.join(',')}, error=${error.message}`
);
}
}
/**
* 通过拣货任务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;
// 复核统计仅计非拦截订单(拦截订单保留在 list 中按单提示)
const reviewableOrders = mergedList.filter(
o => !this.isInterceptedOrderStatus(o.intercept_status)
);
const reviewedCount = reviewableOrders.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = reviewableOrders.length - 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。
* 拦截订单保留在 list 中(带 intercept_status),不参与复核校验与 reviewed/unreviewed/printed 统计,
* 波次内存在拦截订单时不再阻断整个扫描视图加载(与团购模式一致)。
* @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 : [];
// 分离拦截订单:拦截订单保留在 list 中由前端按单提示拦截(intercept_status),
// 仅对非拦截订单做复核校验与统计,与团购模式一致,
// 波次内存在拦截订单时不再阻断整个散单扫描视图加载
const normalOrders = orders.filter(
order => !this.isInterceptedOrderStatus(order.intercept_status)
);
// 校验波次内非拦截订单是否都已拣货,未拣货订单不允许复核
for (const order of normalOrders) {
this.assertOrderCanRecheck(order);
}
// 并行查询拣货人信息和策略信息
const [ pickerInfo, strategyInfo ] = await Promise.all([
this.getPickerInfoByWaveId(normalizedWaveId, warehouseId),
this.getWaveStrategyInfo(normalizedWaveId, warehouseId),
]);
// 计算复核汇总(仅统计非拦截订单)
const reviewedCount = normalOrders.filter(o => o.recheck_status === 'fin').length;
const unreviewedCount = normalOrders.length - reviewedCount;
// 计算打印汇总(仅统计非拦截订单)
const printedCount = normalOrders.filter(o => o.is_printed === true).length;
const unprintedCount = normalOrders.length - printedCount;
// 批量查询包材推荐
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(orders, warehouseId);
// 查询任务框的 stock_id → box_no 映射(用于先拣后分等散单模式)
const taskId = pickerInfo.task_id;
const boxNoByStockId = new Map();
if (taskId > 0) {
const { ctx } = this;
const boxRows = await ctx.model.query(
`SELECT ref_id, box_no
FROM wms_wave_pick_task_box
WHERE task_id = :taskId`,
{
replacements: { taskId },
type: ctx.model.QueryTypes.SELECT,
}
);
for (const row of (Array.isArray(boxRows) ? boxRows : [])) {
const sid = Number(row.ref_id || 0);
const bno = Number(row.box_no || 0);
if (sid > 0 && bno > 0 && !boxNoByStockId.has(sid)) {
boxNoByStockId.set(sid, bno);
}
}
}
// 为每个订单附加 items_weight、包材推荐和 stock 中的 box_no
const enrichedOrders = orders.map(order => {
const itemsHash = String(order.items_hash || '').trim();
const enrichedStock = Array.isArray(order.stock)
? order.stock.map(stockItem => ({
...stockItem,
box_no: boxNoByStockId.get(Number(stockItem.stock_id || 0)) || 0,
}))
: [];
return {
...order,
stock: enrichedStock,
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、waybill_no、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 (this.isInterceptedOrderStatus(interceptStatus)) {
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(),
pick_requirements: String(item.pick_requirements || '').trim(),
recheck_requirements: String(item.recheck_requirements || '').trim(),
merge_requirements: String(item.merge_requirements || 'Y').trim(),
barcodes: Array.isArray(item.barcodes) ? [ ...item.barcodes ] : [],
images: Array.isArray(item.images) ? [ ...item.images ] : [],
has_shared_barcode: Boolean(item.has_shared_barcode),
need_recheck: String(item.need_recheck || 'Y').trim(),
need_sn: String(item.need_sn || 'N').trim().toUpperCase() === 'Y' ? 'Y' : 'N',
sn_code_rules: Array.isArray(item.sn_code_rules)
? item.sn_code_rules.map(rule => ({ ...rule }))
: [],
plan_qty: Number(item.plan_qty || 0),
store_id: item.store_id != null ? Number(item.store_id) : 0,
owner_code: String(item.owner_code || '').trim(),
store_remark: String(item.store_remark || '').trim(),
}));
// 构建拦截订单列表(wave_index 即波次内序号,供前端展示拦截订单的序号)
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(),
waybill_no: String(order.waybill_no || '').trim(),
intercept_status: String(order.intercept_status || '').trim(),
}));
// 计算波次内复核统计(基于非拦截订单的 recheck_status 实时聚合)
const reviewedCount = normalOrders.filter(o => String(o.recheck_status || '').trim() === 'fin').length;
const unreviewedCount = normalOrders.length - reviewedCount;
// 计算波次内打印统计(基于非拦截订单的 is_printed 字段)
const printedCount = normalOrders.filter(o => o.is_printed === true).length;
const unprintedCount = normalOrders.length - printedCount;
// 使用任务级别的 pick_mode 覆盖(团单模式下以任务为准)
const result = {
wave_id: waveView.wave_id,
wave_no: waveView.wave_no,
wave_type: waveView.wave_type,
wave_status: waveView.wave_status,
pick_mode: pickMode,
total_orders: waveView.total_orders,
processed_orders: waveView.processed_orders,
creator: waveView.creator,
create_time: waveView.create_time,
update_time: waveView.update_time,
order_count: waveView.order_count,
box_no: Number(tw.box_no || 0),
stocks,
store_id: sampleOrder ? Number(sampleOrder.store_id || 0) : 0,
store_remark: sampleOrder ? String(sampleOrder.store_remark || '').trim() : '',
reviewed_count: reviewedCount,
unreviewed_count: unreviewedCount,
printed_count: printedCount,
unprinted_count: unprintedCount,
};
// 仅当存在拦截订单时才追加 intercepted 字段
if (intercepted.length > 0) {
result.intercepted = intercepted;
}
// 团购波次内所有订单商品结构一致,暂存样本订单的商品指纹信息用于后续批量查询包材推荐
result._sample_hash = sampleOrder ? String(sampleOrder.items_hash || '').trim() : '';
result._sample_crc = sampleOrder ? Number(sampleOrder.items_crc || 0) : 0;
result.items_weight = sampleOrder ? Number(sampleOrder.items_weight || 0) : 0;
result.suggested_package_material = null;
// 波次内首个订单的运单号,用于包材绑定等后续操作
// 优先取首个正常订单的运单号,若无正常订单则取首个订单(含拦截)的运单号,均无则为空字符串
const firstNonIntercepted = normalOrders.length > 0 ? normalOrders[0] : null;
const firstAnyOrder = orders.length > 0 ? orders[0] : null;
const firstOrderForWaybill = firstNonIntercepted || firstAnyOrder;
result.first_waybill_no = firstOrderForWaybill
? String(firstOrderForWaybill.waybill_no || '').trim()
: '';
return result;
});
const waveViews = (await Promise.all(waveViewPromises)).filter(view => view !== null);
// 批量查询所有波次的包材推荐
if (waveViews.length > 0) {
const sampleOrdersForPackageQuery = waveViews
.filter(wv => wv._sample_hash)
.map(wv => ({ items_hash: wv._sample_hash, items_crc: wv._sample_crc }));
const packageMaterialMap = await this.batchQueryPackageMaterialRecommendation(
sampleOrdersForPackageQuery,
warehouseId
);
for (const wv of waveViews) {
if (wv._sample_hash) {
wv.suggested_package_material = packageMaterialMap.get(wv._sample_hash) || null;
}
// 清理内部临时字段
delete wv._sample_hash;
delete wv._sample_crc;
}
}
return waveViews;
}
/**
* 通过波次ID查询关联的拣货模式。
* 优先查询 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 拣货模式编码,未找到返回 0。
*/
async getPickModeByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return 0;
}
// 先按 wave_id 直接查拣货任务
const taskRows = await ctx.model.query(
`
SELECT pick_mode
FROM wms_wave_pick_task
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
ORDER BY create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(taskRows) && taskRows.length > 0) {
return Number(taskRows[0].pick_mode || 0);
}
// 通过 wms_wave_pick_task_wave 关联查询
const twRows = await ctx.model.query(
`
SELECT t.pick_mode
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
ORDER BY t.create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(twRows) && twRows.length > 0) {
return Number(twRows[0].pick_mode || 0);
}
return 0;
}
/**
* 根据波次ID查询关联的拣货任务ID。
* 优先查 wms_wave_pick_task.wave_id,其次查 wms_wave_pick_task_wave 关联表。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 拣货任务ID,未找到返回 0。
*/
async getTaskIdByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return 0;
}
// 先按 wave_id 直接查拣货任务
const taskRows = await ctx.model.query(
`
SELECT id AS task_id
FROM wms_wave_pick_task
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId
ORDER BY create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(taskRows) && taskRows.length > 0) {
return Number(taskRows[0].task_id || 0);
}
// 通过 wms_wave_pick_task_wave 关联查询
const twRows = await ctx.model.query(
`
SELECT tw.task_id
FROM wms_wave_pick_task_wave tw
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
ORDER BY tw.task_id DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(twRows) && twRows.length > 0) {
return Number(twRows[0].task_id || 0);
}
return 0;
}
/**
* 查询波次下所有订单的基本信息列表。
* 包含运单号、打印状态、复核状态、波次内序号(优先从 wms_order_wave_index 读取真实 wave_index,
* 若表无记录则降级使用 Array.map 临时序号),按未复核优先 + 波次内序号升序排序。
* @param {string} waveNo 波次号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Array<Object>>} 订单基本信息列表,每项含 order_id、delivery_order_code、
* waybill_no、pick_status、is_printed、is_reviewed、shop_nick、items_count、
* wave_index、recheck_status、wave_id、wave_no、order_type、status、
* logistics_name、store_remark、intercept_status、items_weight、items_hash、items_crc、stock 等字段。
*/
async getWaveOrdersBasic(waveNo, warehouseId) {
const normalizedWaveNo = String(waveNo || '').trim();
if (!normalizedWaveNo) {
return [];
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_no: normalizedWaveNo,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
attributes: [
'id',
'delivery_order_code',
'pre_delivery_order_code',
'pick_status',
'wave_id',
'wave_no',
'order_type',
'status',
'recheck_status',
'items_count',
'shop_nick',
'logistics_name',
'print_status',
'store_id',
'intercept_status',
'items_weight',
'packages_weight',
'items_hash',
'items_crc',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const { ctx } = this;
const orderRowsArray = Array.isArray(orderRows) ? orderRows : [];
const orderIds = orderRowsArray.map(row => Number(row.id || 0));
// 批量查询货主备注(wms_store_warehouse.store_remask)
const storeRemarkMap = new Map();
if (orderIds.length > 0 && ctx.model && ctx.model.StoreWarehouse) {
const storeIds = [
...new Set(
orderRowsArray
.map(row => Number(row.store_id || 0))
.filter(id => id > 0)
),
];
if (storeIds.length > 0) {
const swRows = await ctx.model.StoreWarehouse.findAll({
where: {
store_id: { [this.app.Sequelize.Op.in]: storeIds },
warehouse_id: warehouseId,
},
attributes: [ 'store_id', 'store_remask' ],
raw: true,
});
for (const sw of (Array.isArray(swRows) ? swRows : [])) {
const sid = Number(sw.store_id || 0);
if (sid > 0 && !storeRemarkMap.has(sid)) {
storeRemarkMap.set(sid, String(sw.store_remask || '').trim());
}
}
}
}
// 批量查询运单信息
const waybillMap = new Map();
if (orderIds.length > 0 && ctx.model && ctx.model.OrderExpress) {
const expressRows = await ctx.model.OrderExpress.findAll({
where: { order_id: orderIds, warehouse_id: warehouseId },
attributes: [ 'order_id', 'waybill_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
for (const er of (Array.isArray(expressRows) ? expressRows : [])) {
const oid = Number(er.order_id || 0);
if (oid > 0 && !waybillMap.has(oid)) {
waybillMap.set(oid, String(er.waybill_code || '').trim());
}
}
}
// 批量查询波次顺序索引(wms_order_wave_index)
const waveIndexMap = new Map();
if (orderIds.length > 0 && ctx.model && typeof ctx.model.query === 'function') {
const waveIds = [
...new Set(
orderRowsArray
.map(row => Number(row.wave_id || 0))
.filter(id => id > 0)
),
];
if (waveIds.length > 0) {
try {
const waveIndexRows = await ctx.model.query(
`
SELECT order_id, wave_index
FROM wms_order_wave_index
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
AND order_id IN (:orderIds)
`,
{
replacements: { warehouseId, waveIds, orderIds },
type: ctx.model.QueryTypes && ctx.model.QueryTypes.SELECT,
}
);
for (const wr of (Array.isArray(waveIndexRows) ? waveIndexRows : [])) {
const wrOrderId = Number(wr && wr.order_id || 0);
if (wrOrderId > 0) {
waveIndexMap.set(wrOrderId, Number(wr.wave_index || 0));
}
}
} catch (e) {
ctx.logger.warn(`[recheckOrder.getWaveOrdersBasic] 查询波次索引失败, waveNo=${normalizedWaveNo}, error=${e.message}`);
}
}
}
// 构建订单列表
const orderList = orderRowsArray.map((row, index) => {
const orderId = Number(row.id || 0);
const recheckStatus = String(row.recheck_status || '').trim();
const printStatus = String(row.print_status || '').trim();
// 运单号:从 wms_order_express 关联表查询
const waybillNo = waybillMap.has(orderId) ? (waybillMap.get(orderId) || '') : '';
return {
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || row.pre_delivery_order_code || '').trim(),
waybill_no: waybillNo,
pick_status: String(row.pick_status || '').trim(),
is_printed: printStatus === 'fin',
is_reviewed: recheckStatus === 'fin',
shop_nick: String(row.shop_nick || '').trim(),
items_count: Number(row.items_count || 0),
wave_index: waveIndexMap.has(orderId) ? waveIndexMap.get(orderId) : index,
recheck_status: recheckStatus,
wave_id: Number(row.wave_id || 0),
wave_no: String(row.wave_no || '').trim(),
order_type: String(row.order_type || '').trim(),
status: Number(row.status || 0),
logistics_name: String(row.logistics_name || '').trim(),
store_id: Number(row.store_id || 0),
store_remark: storeRemarkMap.has(Number(row.store_id || 0))
? storeRemarkMap.get(Number(row.store_id || 0))
: '',
intercept_status: String(row.intercept_status || '').trim(),
items_weight: Number(row.items_weight || 0),
packages_weight: Number(row.packages_weight || 0),
items_hash: String(row.items_hash || '').trim(),
items_crc: Number(row.items_crc || 0),
};
});
// 排序:未复核的排前面,其次按波次内序号从小到大
orderList.sort((a, b) => {
const aReviewed = a.is_reviewed ? 1 : 0;
const bReviewed = b.is_reviewed ? 1 : 0;
if (aReviewed !== bReviewed) {
return aReviewed - bReviewed;
}
return a.wave_index - b.wave_index;
});
// 补充库存信息
const enrichedList = await this.enrichOrdersWithStock(orderList, warehouseId);
return enrichedList;
}
/**
* 批量查询包材推荐信息。
* 根据订单的 items_hash + items_crc 组合,从 wms_package_material_item_relation 表
* 查询最匹配的包材推荐(按 bind_count 降序取 top-1)。
* @param {Object[]} orderList 订单列表,每项需含 items_hash、items_crc 字段。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Map<string, Object|null>>} 以 items_hash 为键的包材推荐映射,
* 值为包材信息对象或 null(无推荐时)。
*/
async batchQueryPackageMaterialRecommendation(orderList, warehouseId) {
const resultMap = new Map();
if (!Array.isArray(orderList) || orderList.length === 0) {
return resultMap;
}
// 收集所有有效的 items_hash,并为每个 hash 记录对应的 items_crc
const hashCrcMap = new Map();
for (const order of orderList) {
const hash = String(order.items_hash || '').trim();
if (!hash) {
continue;
}
const crc = Number(order.items_crc || 0);
if (!hashCrcMap.has(hash)) {
hashCrcMap.set(hash, crc);
}
}
if (hashCrcMap.size === 0) {
return resultMap;
}
const uniqueHashes = [ ...hashCrcMap.keys() ];
const { ctx } = this;
if (!ctx.model || typeof ctx.model.query !== 'function') {
return resultMap;
}
// 批量查询所有匹配的包材绑定记录,按 bind_count 降序
let relationRows = [];
try {
relationRows = await ctx.model.query(
`SELECT * FROM wms_package_material_item_relation
WHERE warehouse_id = :warehouseId
AND items_hash IN (:uniqueHashes)
AND is_active = 1
AND delete_at IS NULL
ORDER BY bind_count DESC`,
{
replacements: { warehouseId, uniqueHashes },
type: ctx.model.QueryTypes.SELECT,
}
);
} catch (e) {
ctx.logger.warn(`[recheckOrder.batchQueryPackageMaterialRecommendation] 查询包材推荐失败, error=${e.message}`);
return resultMap;
}
const rows = Array.isArray(relationRows) ? relationRows : [];
// 为每个 items_hash 取第一条匹配记录(已按 bind_count DESC 排序,且 items_crc 匹配)
for (const row of rows) {
const hash = String(row.items_hash || '').trim();
if (!hash || resultMap.has(hash)) {
continue;
}
// 校验 items_crc 是否与订单一致
const expectedCrc = hashCrcMap.get(hash);
const rowCrc = Number(row.items_crc || 0);
if (expectedCrc !== undefined && expectedCrc !== rowCrc) {
continue;
}
resultMap.set(hash, {
id: row.package_material_id,
code: String(row.package_material_code || '').trim() || null,
name: String(row.package_material_name || '').trim() || null,
spec: String(row.package_material_spec || '').trim() || null,
type: String(row.package_material_type || '').trim() || null,
weight: row.weight != null ? Number(row.weight) : null,
length: row.length != null ? Number(row.length) : null,
width: row.width != null ? Number(row.width) : null,
height: row.height != null ? Number(row.height) : null,
bind_count: row.bind_count != null ? Number(row.bind_count) : null,
});
}
return resultMap;
}
/**
* 为订单列表批量补充库存信息。
* 查询每个订单的明细商品、库存数量、条码列表和图片,构建 stock 数组。
* @param {Object[]} orderList 订单基本信息列表。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object[]>} 补充了 stock 字段的订单列表。
*/
async enrichOrdersWithStock(orderList, warehouseId) {
if (!Array.isArray(orderList) || orderList.length === 0) {
return orderList;
}
const orderIds = orderList.map(o => Number(o.order_id || 0)).filter(Boolean);
if (orderIds.length === 0) {
return orderList;
}
// 1. 批量查询所有订单的商品明细
const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId);
const allOrderItems = await orderItemsModel.findAll({
where: {
order_id: { [this.app.Sequelize.Op.in]: orderIds },
},
attributes: [ 'order_id', 'stock_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot', 'owner_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const itemsArray = Array.isArray(allOrderItems) ? allOrderItems : [];
// 2. 收集所有唯一的 stock_id
const stockIds = [ ...new Set(
itemsArray
.map(item => Number(item.stock_id))
.filter(Boolean)
) ];
// 3. 批量查询库存信息(复用 getStockDetails,含条码与图片)
const stockMap = new Map();
const barcodeMap = new Map();
const imagesByStockId = new Map();
if (stockIds.length > 0) {
const stockDetails = await this.ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{ warehouseId }
);
for (const detail of stockDetails) {
const sid = Number(detail.id);
stockMap.set(sid, detail);
// 从 getStockDetails 提取条码
if (Array.isArray(detail.barcodes) && detail.barcodes.length > 0) {
barcodeMap.set(sid, detail.barcodes.map(bc => String(bc.barcode || '').trim()).filter(Boolean));
}
// 从 getStockDetails 提取图片 URL(兼容数组/字符串格式)
const imageUrls = Array.isArray(detail.image_url)
? detail.image_url.map(u => String(u || '').trim()).filter(Boolean)
: (detail.image_url ? [ String(detail.image_url).trim() ] : []);
if (imageUrls.length > 0) {
imagesByStockId.set(sid, imageUrls);
}
}
}
// 3.1 批量查询序列号管理商品(is_sn_mgmt='Y')与其 SN 码规则,用于标记商品行是否需要采集 SN 码
// 并下发 sn_code_rules 供前端扫码校验/加工
const snStockIdSet = new Set();
const snCodeRulesMap = new Map();
if (stockIds.length > 0 && this.ctx && this.ctx.model && this.ctx.model.StockWarehouse) {
const snRows = await this.ctx.model.StockWarehouse.findAll({
where: {
id: { [this.app.Sequelize.Op.in]: stockIds },
warehouse_id: warehouseId,
},
attributes: [ 'id', 'is_sn_mgmt', 'sn_code_rules' ],
raw: true,
paranoid: false,
});
for (const snRow of (Array.isArray(snRows) ? snRows : [])) {
const sid = Number(snRow && snRow.id || 0);
if (sid <= 0) {
continue;
}
if (String(snRow.is_sn_mgmt || '').trim().toUpperCase() === 'Y') {
snStockIdSet.add(sid);
}
const rules = this.ctx.service.systems.snCodeRule.toRuleList(snRow.sn_code_rules);
if (rules.length > 0) {
snCodeRulesMap.set(sid, rules);
}
}
}
// 4. 批量查询货主备注名(wms_store_warehouse.store_remask),按 store_id 映射
const storeRemarkMapByStock = new Map();
if (stockMap.size > 0 && this.ctx.model && this.ctx.model.StoreWarehouse) {
const storeIdsForRemark = [ ...new Set(
[ ...stockMap.values() ]
.map(detail => Number(detail.store_id || 0))
.filter(id => id > 0)
) ];
if (storeIdsForRemark.length > 0) {
const swRows = await this.ctx.model.StoreWarehouse.findAll({
where: {
store_id: { [this.app.Sequelize.Op.in]: storeIdsForRemark },
warehouse_id: warehouseId,
},
attributes: [ 'store_id', 'store_remask' ],
raw: true,
});
for (const sw of (Array.isArray(swRows) ? swRows : [])) {
const sid = Number(sw.store_id || 0);
if (sid > 0 && !storeRemarkMapByStock.has(sid)) {
storeRemarkMapByStock.set(sid, String(sw.store_remask || '').trim());
}
}
}
}
// 5. 检测共享条码:以订单货主(store_id)为判定范围,
// 仅当条码在订单货主下(wms_stock_warehouse.store_id = 订单 store_id)绑定到多个不同 stock_id 时视为共享;
// 跨货主同码不提示。无货主(store_id<=0)的订单不做共享判定。
// 已删除(delete_at/deleted_at 非空)或弃用(is_valid≠'Y')的商品资料不参与共享判定。
const sharedBarcodeMap = new Map();
if (barcodeMap.size > 0) {
const allBarcodes = [];
for (const [ , barcodes ] of barcodeMap) {
for (const bc of barcodes) {
allBarcodes.push(bc);
}
}
const orderStoreIds = [ ...new Set(
orderList
.map(order => Number(order.store_id || 0))
.filter(storeId => storeId > 0)
) ];
if (allBarcodes.length > 0
&& orderStoreIds.length > 0
&& this.ctx.model
&& this.ctx.model.StockBarcode) {
const sharedRows = await this.ctx.model.query(
`SELECT sb.barcode, sw.store_id, COUNT(DISTINCT sb.stock_id) AS cnt
FROM wms_stock_barcodes sb
INNER JOIN wms_stock_warehouse sw
ON sw.id = sb.stock_id
AND sw.is_valid = 'Y'
AND sw.delete_at IS NULL
AND sw.deleted_at IS NULL
WHERE sb.barcode IN (:barcodes)
AND sb.warehouse_id = :warehouseId
AND sw.warehouse_id = :warehouseId
AND sw.store_id IN (:orderStoreIds)
GROUP BY sb.barcode, sw.store_id
HAVING cnt > 1`,
{
replacements: { barcodes: allBarcodes, warehouseId, orderStoreIds },
type: this.ctx.model.QueryTypes.SELECT,
}
);
for (const row of (Array.isArray(sharedRows) ? sharedRows : [])) {
const rowStoreId = Number(row.store_id || 0);
const rowBarcode = String(row.barcode || '').trim();
if (rowStoreId <= 0 || !rowBarcode) {
continue;
}
if (!sharedBarcodeMap.has(rowStoreId)) {
sharedBarcodeMap.set(rowStoreId, new Set());
}
sharedBarcodeMap.get(rowStoreId).add(rowBarcode);
}
}
}
// 6. 按 order_id 分组商品明细
const itemsByOrderId = new Map();
for (const item of itemsArray) {
const oid = Number(item.order_id);
if (!itemsByOrderId.has(oid)) {
itemsByOrderId.set(oid, []);
}
itemsByOrderId.get(oid).push(item);
}
// 7. 为每个订单构建 stock 数组
return orderList.map(order => {
const oid = Number(order.order_id || 0);
const items = itemsByOrderId.get(oid) || [];
const stock = items.map(item => {
const sid = Number(item.stock_id || 0);
const stockInfo = stockMap.get(sid) || {};
const barcodes = (() => {
const arr = barcodeMap.get(sid);
if (Array.isArray(arr) && arr.length > 0) {
return arr;
}
return [ String(item.item_code || '').trim() ];
})();
const images = imagesByStockId.get(sid) || [];
const hasSharedBarcode = (() => {
const arr = barcodeMap.get(sid);
const orderStoreId = Number(order.store_id || 0);
const sharedBarcodeSet = orderStoreId > 0 ? sharedBarcodeMap.get(orderStoreId) : null;
if (Array.isArray(arr) && arr.length > 0 && sharedBarcodeSet) {
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(),
pick_requirements: String(stockInfo.pick_requirements || '').trim(),
recheck_requirements: String(stockInfo.recheck_requirements || '').trim(),
merge_requirements: String(stockInfo.merge_requirements || 'Y').trim(),
barcodes,
images,
has_shared_barcode: hasSharedBarcode,
need_recheck: String(stockInfo.need_recheck || 'Y').trim(),
need_sn: snStockIdSet.has(sid) ? 'Y' : 'N',
sn_code_rules: snCodeRulesMap.get(sid) || [],
plan_qty: Number(item.plan_qty || 0),
store_id: stockInfo.store_id != null ? Number(stockInfo.store_id) : 0,
owner_code: String(item.owner_code || '').trim(),
store_remark: storeRemarkMapByStock.get(stockInfo.store_id != null ? Number(stockInfo.store_id) : 0) || '',
};
});
return {
...order,
stock,
};
});
}
/**
* 通过波次ID查询关联的拣货人信息及任务ID。
* 通过 wms_wave_pick_task_wave 关联 wms_wave_pick_task 获取 pick_user_id / pick_user_name / task_id。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ picker_id: number|null, picker_name: string, task_id: number|null }>} 拣货人信息及任务ID。
*/
async getPickerInfoByWaveId(waveId, warehouseId) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
if (normalizedWaveId <= 0) {
return { picker_id: null, picker_name: '', task_id: null };
}
const rows = await ctx.model.query(
`
SELECT t.pick_user_id, t.pick_user_name, t.id AS task_id
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
AND t.pick_user_id IS NOT NULL
ORDER BY t.create_time DESC
LIMIT 1
`,
{
replacements: { waveId: normalizedWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const row = Array.isArray(rows) && rows.length > 0 ? rows[0] : null;
return {
picker_id: row && row.pick_user_id != null ? Number(row.pick_user_id) : null,
picker_name: String(row && row.pick_user_name || '').trim(),
task_id: row && row.task_id != null ? Number(row.task_id) : null,
};
}
/**
* 通过拣货任务ID查询拣货人信息。
* @param {number} taskId 拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ picker_id: number|null, picker_name: string }>} 拣货人信息。
*/
async getPickerInfoByTaskId(taskId, warehouseId) {
const { ctx } = this;
const normalizedTaskId = Number(taskId || 0);
if (normalizedTaskId <= 0) {
return { picker_id: null, picker_name: '' };
}
const rows = await ctx.model.query(
`
SELECT pick_user_id, pick_user_name
FROM wms_wave_pick_task
WHERE id = :taskId
AND warehouse_id = :warehouseId
LIMIT 1
`,
{
replacements: { taskId: normalizedTaskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const row = Array.isArray(rows) && rows.length > 0 ? rows[0] : null;
return {
picker_id: row && row.pick_user_id != null ? Number(row.pick_user_id) : null,
picker_name: String(row && row.pick_user_name || '').trim(),
};
}
/**
* 查询波次关联的策略信息。
* 当前 wms_wave_batch 与 wms_wave_pick_task 均未直接存储 strategy_id,
* 因此默认返回 null,后续若补充关联字段可在此扩展查询逻辑。
* @param {number} waveId 波次ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<{ strategy_id: number|null, strategy_name: string }>} 策略信息。
*/
// eslint-disable-next-line no-unused-vars
async getWaveStrategyInfo(waveId, warehouseId) {
return {
strategy_id: null,
strategy_name: '',
};
}
/**
* 兼容旧方法名,内部统一转发到 scanOrder。
* @param {Object} data 请求体。
* @return {Promise<Object>} 扫描结果。
*/
async scanWaybill(data = {}) {
return await this.scanOrder(data);
}
/**
* 确认订单已复核,并写入复核任务记录。
* 支持两种模式:传入 wave_id 时走团购波次批量复核,否则走单订单复核。
* @param {Object} data 请求体。
* @param {number|string} [data.wave_id] 波次ID,传入时触发团购波次批量复核。
* @param {number|string} [data.order_id] 订单ID。
* @param {number|string} [data.id] 订单ID别名。
* @param {number|string} [data.orderId] 订单ID别名。
* @return {Promise<Object>} 复核确认结果。
*/
async confirmRecheck(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const warehouseId = this.getWarehouseId();
// 团购波次批量复核
const { wave_id: waveId } = requestData;
if (waveId) {
return await this.confirmRecheckByWaveId(Number(waveId), warehouseId);
}
const { ctx } = this;
const orderId = this.resolveOrderId(data);
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
const order = await orderModel.findOne({
where: orderWhere,
raw: true,
});
if (!order) {
throw new Error('未找到对应订单');
}
this.assertOrderCanRecheck(order);
const expresses = await this.getOrderExpressesByOrderId(orderId, order);
const waybillNo = String(expresses?.[0]?.waybill_code || '').trim();
const now = new Date();
const operator = this.getOrderLogOperator();
const updateValues = {
recheck_status: 'fin',
recheck_time: now,
updated_at: now,
};
// SN(序列号管理)订单必须随复核提交 SN 码:SN 落库与复核状态更新同事务,任一失败整体回滚
const needSnVerify = this.isSnOrderRow(order) || this.hasRecheckSnPayload(requestData);
const transaction = needSnVerify ? await ctx.model.transaction() : null;
let snSummary = { sn_count: 0, sn_item_count: 0, sn_created_count: 0, sn_reused_count: 0 };
try {
if (transaction) {
snSummary = await this.verifyRecheckSnForOrder({
order,
warehouseId,
requestData,
operator,
now,
transaction,
});
}
const updateResult = await orderModel.update(updateValues, {
where: orderWhere,
...(transaction ? { transaction } : {}),
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
if (affectedRows <= 0) {
throw new Error('未找到对应订单');
}
if (transaction) {
await transaction.commit();
}
} catch (error) {
if (transaction) {
await transaction.rollback();
}
throw error;
}
const reviewNo = this.buildRecheckReviewNo(orderId, now);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const operatorNo = String(operator.id || '').trim();
const operatorName = String(operator.name || '').trim();
await ctx.model.query(
`
INSERT INTO wms_recheck_task (
review_no,
warehouse_id,
order_id,
order_no,
waybill_no,
task_status,
scan_status,
review_emp_no,
review_emp_name,
scan_emp_no,
scan_emp_name,
scan_time,
finish_time,
remark
)
VALUES (
:reviewNo,
:warehouseId,
:orderId,
:orderNo,
:waybillNo,
:taskStatus,
:scanStatus,
:reviewEmpNo,
:reviewEmpName,
:scanEmpNo,
:scanEmpName,
:scanTime,
:finishTime,
:remark
)
`,
{
replacements: {
reviewNo,
warehouseId,
orderId,
orderNo,
waybillNo,
taskStatus: 2,
scanStatus: 1,
reviewEmpNo: operatorNo,
reviewEmpName: operatorName,
scanEmpNo: operatorNo,
scanEmpName: operatorName,
scanTime: now,
finishTime: now,
remark: '系统复核完成',
},
type: ctx.model.QueryTypes.INSERT,
}
);
// 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务
await this.updateTaskOrderReviewAndTryUnbindCart(orderId, warehouseId, operator, now);
// 写入操作日志
await this._writeRecheckActionLog({
orderId,
waybillNo,
warehouseId,
operator,
now,
});
// 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成,
// 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失
await this._tryCompleteWaveIfAllOrdersRechecked(orderId, order.wave_id, warehouseId, operator, now);
// 通知仓库面板刷新(大屏增量更新,失败不影响主流程)
await this.service.systems.warehousePanel.touchLastChangeAt(Number(warehouseId));
// SN 订单此前被自动回传链路跳过(未复核 + SN 未齐套),复核通过后 SN 明细已齐套,
// 按货主-仓库签约策略 auto_sync_back 异步回传一次,失败不影响复核结果
await this._tryAutoSyncBackAfterRecheck({ order, warehouseId, source: 'confirmRecheck' });
return {
order_id: orderId,
waybill_no: waybillNo,
recheck_status: 'fin',
recheck_time: now,
review_no: reviewNo,
has_sn_item: this.isSnOrderRow(order) ? 'Y' : 'N',
sn_count: snSummary.sn_count || 0,
sn_item_count: snSummary.sn_item_count || 0,
};
}
/**
* 判断订单是否为 SN(序列号管理)订单。
* @param {Object} order 订单主表行。
* @return {boolean} 是否 SN 订单。
*/
isSnOrderRow(order = {}) {
return String((order && order.has_sn_item) || '').trim().toUpperCase() === 'Y';
}
/**
* 复核通过后对 SN 订单异步触发一次回传。
*
* SN 订单在运单分配阶段被 auto_sync_back 前置过滤跳过(此时未复核、SN 明细未写入),
* 复核通过后 SN 明细已齐套,需要补一次回传。仅处理 SN 订单,且受货主-仓库签约策略
* policy_config.auto_sync_back 控制;任何异常只写日志,不影响复核结果。
*
* @param {Object} params 参数。
* @param {Object} params.order 订单主表行(需含 id / store_id / has_sn_item / sync_status)。
* @param {number|string} params.warehouseId 仓库ID。
* @param {string} [params.source] 触发来源(仅用于日志定位)。
* @return {Promise<void>} 无返回值。
*/
async _tryAutoSyncBackAfterRecheck({ order = {}, warehouseId, source = 'confirmRecheck' }) {
const { ctx } = this;
try {
if (!this.isSnOrderRow(order)) {
return;
}
const orderId = Number(order.id);
if (!Number.isInteger(orderId) || orderId <= 0) {
return;
}
if (String(order.sync_status || '').trim() === 'fin') {
return;
}
const storeId = Number(order.store_id) || 0;
if (storeId <= 0) {
ctx.logger.warn('[auto_sync_back] SN订单缺少货主 store_id,跳过复核后自动回传', {
warehouseId,
orderId,
source,
});
return;
}
const contractWarehouseId = Number(order.warehouse_id) || Number(warehouseId);
const storeWarehouseService = this.service.systems && this.service.systems.storeWarehouse;
if (!storeWarehouseService || typeof storeWarehouseService.getContractConfig !== 'function') {
ctx.logger.warn('[auto_sync_back] 签约策略服务不可用,跳过复核后自动回传', {
warehouseId,
orderId,
source,
});
return;
}
const contractConfig = await storeWarehouseService.getContractConfig(contractWarehouseId, storeId);
const policyConfig = contractConfig && contractConfig.policy_config ? contractConfig.policy_config : {};
if (policyConfig.auto_sync_back !== 1) {
ctx.logger.info('[auto_sync_back] 未开启自动同步回传,跳过复核后自动回传', {
warehouseId: contractWarehouseId,
orderId,
storeId,
source,
});
return;
}
const pendingOrderService = ctx.service
&& ctx.service.systemMethods
&& ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.pendingOrder;
if (!pendingOrderService || typeof pendingOrderService.syncOrderIds !== 'function') {
ctx.logger.warn('[auto_sync_back] 待处理订单服务不可用,跳过复核后自动回传', {
warehouseId: contractWarehouseId,
orderId,
source,
});
return;
}
ctx.logger.info('[auto_sync_back] 复核完成,触发SN订单自动回传', {
warehouseId: contractWarehouseId,
orderId,
storeId,
source,
});
pendingOrderService.syncOrderIds({
orderIds: [ orderId ],
warehouse_id: contractWarehouseId,
}).catch(err => {
ctx.logger.error(
`[auto_sync_back] ${source} 复核后自动回传失败: ${err && err.message ? err.message : err}`
);
});
} catch (error) {
ctx.logger.error(
`[auto_sync_back] ${source} 复核后自动回传异常: ${error && error.message ? error.message : error}`
);
}
}
/**
* 判断复核入参是否提交了 SN 码内容(唯一格式:sn_map = { stock_id: [sn_code] })。
* @param {Object} payload 复核请求体。
* @return {boolean} 是否提交了 SN 码。
*/
hasRecheckSnPayload(payload = {}) {
const requestData = this.isPlainObject(payload) ? payload : {};
const snMap = requestData.sn_map ?? requestData.snMap;
if (!this.isPlainObject(snMap)) {
return false;
}
return Object.values(snMap).some(value => {
if (Array.isArray(value)) {
return value.some(code => String(code === undefined || code === null ? '' : code).trim() !== '');
}
return String(value === undefined || value === null ? '' : value).trim() !== '';
});
}
/**
* 复核提交时校验并写入 SN 码,具体规则由 systems.orderItemSn 承担。
* @param {Object} params 参数。
* @param {Object} params.order 订单主表行。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Object} params.requestData 复核请求体。
* @param {Object} params.operator 操作人。
* @param {Date} params.now 复核时间。
* @param {Object} params.transaction Sequelize 事务。
* @return {Promise<Object>} SN 提交汇总。
*/
async verifyRecheckSnForOrder({ order, warehouseId, requestData, operator, now, transaction }) {
const snService = this.service && this.service.systems
? (this.service.systems.orderItemSn || this.service.systems.order_item_sn)
: null;
if (!snService || typeof snService.verifyRecheckSnList !== 'function') {
throw new Error('SN码校验服务不可用,无法提交复核');
}
return await snService.verifyRecheckSnList({
order,
warehouseId,
payload: requestData,
operator,
now,
transaction,
});
}
/**
* 团购波次批量复核:将波次下所有非拦截订单标记为已复核,并更新波次批次状态为复核完成。
* @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',
'has_sn_item',
],
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 (this.isInterceptedOrderStatus(String(order.intercept_status || '').trim())) {
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);
}
// SN 订单必须逐单提交 SN 码,团购波次批量复核没有 SN 采集入口,直接拒绝
if (normalOrders.some(order => this.isSnOrderRow(order))) {
throw new Error('SN订单不支持团购波次复核,请使用单订单复核并提交SN码');
}
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,
orderIds: normalOrderIds,
normalOrderCount: normalOrders.length,
interceptedOrderCount: interceptedOrders.length,
totalOrderCount: orderList.length,
now,
});
// 通知仓库面板刷新(大屏增量更新,失败不影响主流程)
await this.service.systems.warehousePanel.touchLastChangeAt(Number(warehouseId));
return {
wave_id: normalizedWaveId,
success_count: normalOrders.length,
intercepted_count: interceptedOrders.length,
total_count: orderList.length,
};
}
/**
* 写入复核操作日志(内部方法)。
* - 写 wms_wave_pick_action_log 一条复核动作日志;
* - 双写 wms_operation_log:团购批量复核按波次写一条 ORDER_RECHECK_BATCH,
* 同时按订单逐单写 ORDER_RECHECK,保证订单操作日志列表中可见。
*
* @param {Object} params 日志参数。
* @param {number} [params.orderId] 订单ID(单订单复核场景)。
* @param {string} [params.waybillNo] 运单号(单订单复核场景)。
* @param {number} [params.waveId] 波次ID(团购批量复核场景)。
* @param {string} [params.waveNo] 波次号(团购批量复核场景)。
* @param {number[]} [params.orderIds] 复核成功的订单ID数组(团购批量复核场景,用于逐单写订单级日志)。
* @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,
orderIds,
warehouseId,
operator,
normalOrderCount,
interceptedOrderCount,
totalOrderCount,
now,
} = params;
const operatorId = operator && operator.id ? Number(operator.id) : 0;
const operatorName = operator && operator.name ? String(operator.name).trim() : 'system';
const isBatch = waveId !== undefined && waveId !== null;
const tag = isBatch ? 'recheck_batch' : 'recheck';
const requestId = `${tag}_${warehouseId}_${isBatch ? waveId : orderId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
await this.ctx.model.query(
`INSERT INTO wms_wave_pick_action_log (
task_id,
warehouse_id,
wave_id,
order_id,
sku_id,
location_id,
box_no,
cart_id,
qty_delta,
action_type,
request_id,
operator_id,
device_id,
seq_no,
snapshot
) VALUES (
:taskId,
:warehouseId,
:waveId,
:orderId,
:skuId,
:locationId,
:boxNo,
:cartId,
:qtyDelta,
:actionType,
:requestId,
:operatorId,
:deviceId,
:seqNo,
:snapshot
)`,
{
replacements: {
taskId: 0,
warehouseId: warehouseId || 0,
waveId: isBatch ? waveId : null,
orderId: isBatch ? null : (orderId || 0),
skuId: null,
locationId: null,
boxNo: null,
cartId: null,
qtyDelta: 0,
actionType: isBatch ? 'recheck_batch' : 'recheck',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify(isBatch
? {
wave_id: waveId,
wave_no: waveNo || '',
success_count: normalOrderCount,
intercepted_count: interceptedOrderCount,
total_count: totalOrderCount,
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}
: {
order_id: orderId,
waybill_no: waybillNo || '',
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}),
},
type: this.ctx.model.QueryTypes.INSERT,
}
);
// 双写 order_operation_log(失败不影响主流程)
try {
const ctx = this.ctx;
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (isBatch) {
// 波次复核:按波次记录一条操作日志
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const messageParts = [];
if (waveNo) {
messageParts.push(`波次 ${String(waveNo).trim()}`);
}
messageParts.push(`复核完成,正常${normalOrderCount || 0}单、拦截${interceptedOrderCount || 0}单、总计${totalOrderCount || 0}单`);
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(waveId || ''),
operationCode: 'ORDER_RECHECK_BATCH',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: messageParts.join(''),
waveId,
waveNo: waveNo || '',
normalOrderCount: normalOrderCount || 0,
interceptedOrderCount: interceptedOrderCount || 0,
totalOrderCount: totalOrderCount || 0,
},
}]);
// 逐单补写订单级复核日志(business_id=订单ID),保证订单操作日志列表中可见
const orderIdList = (Array.isArray(orderIds) ? orderIds : [])
.map(id => Number(id))
.filter(id => id > 0);
if (orderIdList.length > 0) {
const waveNoText = waveNo ? `(波次 ${String(waveNo).trim()})` : '';
await operationLogService.createOperationLogs(orderIdList.map(oid => ({
businessType: 'order',
businessId: String(oid),
operationCode: 'ORDER_RECHECK',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: `订单${oid}复核完成${waveNoText}`,
orderId: oid,
},
})));
}
}
} else {
// 单订单复核
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const messageParts = [];
if (waybillNo) {
messageParts.push(`运单 ${String(waybillNo).trim()} `);
}
messageParts.push('订单复核完成');
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId || ''),
operationCode: 'ORDER_RECHECK',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: messageParts.join(''),
orderId: orderId || 0,
waybillNo: waybillNo || '',
},
}]);
}
}
} catch (e) {
this.ctx.logger.warn('[recheckOrder._writeRecheckActionLog] 写入 order_operation_log 失败', {
error: e && e.message,
orderId,
waveId,
warehouseId,
});
}
}
/**
* 更新波次拣货任务订单的复核状态,若任务下所有订单均已复核完成则自动解绑车任务。
* 复核状态更新后,会先清理波次内「已拦截且未打印」的订单(回池),避免其卡住任务完成判定。
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async updateTaskOrderReviewAndTryUnbindCart(orderId, warehouseId, operator, now) {
const { ctx } = this;
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const hasReviewStatus = taskOrderColumnSet.has('review_status');
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
const hasReviewResult = taskOrderColumnSet.has('review_result');
const hasReviewTime = taskOrderColumnSet.has('review_time');
// 若 review_status 列不存在,跳过后续所有逻辑
if (!hasReviewStatus) {
return;
}
const operatorUserId = Number(operator.id) || 0;
const reviewSetClauses = [];
reviewSetClauses.push('review_status = 1');
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
reviewSetClauses.push('update_time = NOW()');
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET ${reviewSetClauses.join(',\n ')}
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: {
orderId,
warehouseId,
operatorUserId,
now,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
// 复核时同步清理波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务/波次完成判定
try {
const currentOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const currentOrder = await currentOrderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
});
const currentWaveId = Number(currentOrder && currentOrder.wave_id || 0);
if (currentWaveId > 0) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: currentWaveId,
warehouseId,
operator,
});
}
} catch (removeErr) {
ctx.logger.warn(`[confirmRecheck] 清理波次未打印拦截订单失败,不影响复核主流程, orderId=${orderId}, error=${removeErr.message}`);
}
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
let resolvedTaskId = Number(
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单所属波次查找关联的拣货任务
if (resolvedTaskId <= 0) {
resolvedTaskId = await this._resolveTaskIdByWaveFallback(orderId, warehouseId);
}
if (resolvedTaskId <= 0) {
return;
}
// 检查该任务下是否所有订单都已复核完成
const allReviewed = await this._checkTaskOrdersAllReviewed(resolvedTaskId, warehouseId);
if (!allReviewed) {
return;
}
// 任务下所有订单均已复核完成,更新任务状态为复核通过,并解绑车任务(失败不影响主流程)
try {
await this.unbindCartForTask(resolvedTaskId, warehouseId, operatorUserId);
ctx.logger.info(
`[confirmRecheck] 车任务解绑成功, taskId=${resolvedTaskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[confirmRecheck] 解绑车任务失败(复核已成功), taskId=${resolvedTaskId}, orderId=${orderId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId: resolvedTaskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
/**
* 团购模式(pick_mode=1/5)回退:通过订单的波次 ID 查找关联的拣货任务 ID。
* wms_wave_pick_task_order 在团购模式下无记录,需要绕道 wave 关联表。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 任务ID,未找到返回 0。
*/
async _resolveTaskIdByWaveFallback(orderId, warehouseId) {
const { ctx } = this;
// 查订单所属 wave_id
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const order = await orderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
});
const orderWaveId = Number(order?.wave_id || 0);
if (orderWaveId <= 0) {
return 0;
}
// 通过 wave_id 查拣货任务(仅限团购模式 pick_mode=1/5)
const taskWaveRows = await ctx.model.query(
`SELECT DISTINCT t.id AS task_id, t.pick_mode
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t
ON t.id = tw.task_id AND t.warehouse_id = :warehouseId
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
AND t.pick_mode IN (1, 5)
LIMIT 1`,
{
replacements: { waveId: orderWaveId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const fallbackTaskId = Number(
(Array.isArray(taskWaveRows) && taskWaveRows.length > 0 ? taskWaveRows[0]?.task_id : 0)
);
if (fallbackTaskId <= 0) {
return 0;
}
// 查任务关联的全部波次(团购任务一车多波次,必须任务下所有波次订单全部复核完成才允许解绑)
const taskAllWaveRows = await ctx.model.query(
`SELECT DISTINCT tw.wave_id
FROM wms_wave_pick_task_wave tw
WHERE tw.task_id = :taskId
AND tw.warehouse_id = :warehouseId`,
{
replacements: { taskId: fallbackTaskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const taskAllWaveIds = (Array.isArray(taskAllWaveRows) ? taskAllWaveRows : [])
.map(r => Number(r?.wave_id || 0))
.filter(id => id > 0);
if (taskAllWaveIds.length === 0) {
return 0;
}
// 检查任务下所有波次的订单是否均已复核完成(团购模式以订单表 recheck_status 为准)
const unreviewedCount = await orderModel.count({
where: {
wave_id: { [ctx.app.Sequelize.Op.in]: taskAllWaveIds },
warehouse_id: warehouseId,
recheck_status: { [ctx.app.Sequelize.Op.ne]: 'fin' },
},
});
return unreviewedCount === 0 ? fallbackTaskId : 0;
}
/**
* 检查拣货任务下是否所有订单均已复核完成。
* - 散单模式:检查 wms_wave_pick_task_order.review_status
* - 团购模式:已由 _resolveTaskIdByWaveFallback 预先校验,此处直接返回 true
*
* @param {number} taskId 拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @return {Promise<boolean>} 全部已复核返回 true。
*/
async _checkTaskOrdersAllReviewed(taskId, warehouseId) {
const { ctx } = this;
// 先确认 wms_wave_pick_task_order 中是否有记录
const totalRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const totalCount = Number(
(Array.isArray(totalRows) && totalRows.length > 0 ? totalRows[0]?.cnt : 0)
);
if (totalCount > 0) {
// 散单模式:检查是否有未复核的订单
const unreviewedRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND review_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const unreviewedCount = Number(
(Array.isArray(unreviewedRows) && unreviewedRows.length > 0 ? unreviewedRows[0]?.cnt : 0)
);
return unreviewedCount === 0;
}
// 团购模式(wms_wave_pick_task_order 无记录):
// 已在 _resolveTaskIdByWaveFallback 中通过订单表的 recheck_status 校验通过
return true;
}
/**
* 批量更新波次拣货任务订单的复核状态,并按任务维度检查是否需要解绑车任务。
* 与单订单版本不同,本方法一次性更新所有相关任务订单的 review_status,
* 再按去重后的 task_id 逐任务判断是否所有订单均已复核完成。
* 复核状态更新后,会先清理受影响波次内「已拦截且未打印」的订单(回池),
* 避免其卡住任务完成判定。
* @param {number[]} orderIds 订单ID列表。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async updateTaskOrdersReviewBatch(orderIds, warehouseId, operator, now) {
const { ctx } = this;
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return;
}
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const hasReviewStatus = taskOrderColumnSet.has('review_status');
if (!hasReviewStatus) {
return;
}
const hasReviewUserId = taskOrderColumnSet.has('review_user_id');
const hasReviewResult = taskOrderColumnSet.has('review_result');
const hasReviewTime = taskOrderColumnSet.has('review_time');
const operatorUserId = Number(operator.id) || 0;
const reviewSetClauses = [ 'review_status = 1' ];
if (hasReviewUserId) reviewSetClauses.push('review_user_id = :operatorUserId');
if (hasReviewResult) reviewSetClauses.push('review_result = 1');
if (hasReviewTime) reviewSetClauses.push('review_time = :now');
reviewSetClauses.push('update_time = NOW()');
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET ${reviewSetClauses.join(',\n ')}
WHERE order_id IN (:orderIds)
AND warehouse_id = :warehouseId`,
{
replacements: { orderIds, warehouseId, operatorUserId, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
// 复核时同步清理受影响波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务完成判定
try {
const cleanupOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const cleanupWaveRows = await cleanupOrderModel.findAll({
where: {
id: { [this.app.Sequelize.Op.in]: orderIds },
warehouse_id: warehouseId,
},
attributes: [ 'wave_id' ],
raw: true,
});
const cleanupWaveIds = [ ...new Set((Array.isArray(cleanupWaveRows) ? cleanupWaveRows : [])
.map(r => Number(r && r.wave_id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
for (const cleanupWaveId of cleanupWaveIds) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: cleanupWaveId,
warehouseId,
operator,
});
}
} catch (removeErr) {
ctx.logger.warn(`[confirmRecheck] 批量复核-清理波次未打印拦截订单失败,不影响主流程, error=${removeErr.message}`);
}
// 查询受影响的去重 task_id
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id IN (:orderIds)
AND warehouse_id = :warehouseId`,
{
replacements: { orderIds, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
let taskIds = (Array.isArray(taskRows) ? taskRows : [])
.map(r => Number(r.task_id || 0))
.filter(id => id > 0);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单的波次 ID 查找关联的拣货任务
if (taskIds.length === 0 && orderIds.length > 0) {
const firstOrderId = orderIds[0];
const fallbackTaskId = await this._resolveTaskIdByWaveFallback(firstOrderId, warehouseId);
if (fallbackTaskId > 0) {
taskIds = [ fallbackTaskId ];
}
}
// 逐任务判断是否所有订单均已复核完成
for (const taskId of taskIds) {
const unreviewedRows = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND review_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const unreviewedCount = Number(
(Array.isArray(unreviewedRows) && unreviewedRows.length > 0 ? unreviewedRows[0]?.cnt : 0)
);
if (unreviewedCount > 0) {
continue;
}
// 任务下所有订单均已复核完成,解绑车任务并更新任务状态
try {
await this.unbindCartForTask(taskId, warehouseId, operatorUserId);
ctx.logger.info(
`[confirmRecheck] 批量复核-车任务解绑成功, taskId=${taskId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[confirmRecheck] 批量复核-解绑车任务失败, taskId=${taskId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
}
/**
* 解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
* @param {number} taskId 波次拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @param {number} operatorUserId 操作员用户ID。
* @return {Promise<void>} 无返回值。
*/
async unbindCartForTask(taskId, warehouseId, operatorUserId) {
const { ctx } = this;
// 停用拣货车绑定记录
await ctx.model.query(
`UPDATE wms_pick_task_cart_binding
SET is_active = 0,
unbind_user_id = :operatorUserId,
unbind_time = NOW(),
update_time = NOW()
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND is_active = 1`,
{
replacements: { taskId, warehouseId, operatorUserId },
type: ctx.model.QueryTypes.UPDATE,
}
);
}
/**
* 从多种兼容字段中解析订单ID。
* @param {Object} data 请求体。
* @return {number} 规范化后的订单ID。
*/
resolveOrderId(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const {
order_id: orderId,
id,
orderId: orderIdAlias,
} = requestData;
const normalizedOrderId = Number(orderId || id || orderIdAlias || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw new Error('订单ID不能为空');
}
return normalizedOrderId;
}
/**
* 从多种兼容字段中解析扫描关键词。
* @param {Object} data 请求体。
* @param {string} [data.wave_no] 波次号。
* @param {string} [data.waveNo] 波次号别名。
* @return {string} 规范化后的扫描关键词。
*/
resolveScanKeyword(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const {
keyword,
value,
waybill_no: waybillNo,
waybillCode,
waybill_code: waybillCodeAlias,
wave_no: waveNo,
waveNo: waveNoAlias,
cart_code: cartCode,
cartCode: cartCodeAlias,
} = requestData;
const normalizedKeyword = String(
keyword || value || waybillNo || waybillCode || waybillCodeAlias || waveNo || waveNoAlias || cartCode || cartCodeAlias || ''
).trim();
if (!normalizedKeyword) {
throw new Error('扫描关键词不能为空');
}
return normalizedKeyword;
}
/**
* 根据扫描关键词解析订单ID。
* 匹配优先级:运单号 → 波次号 → 车号。
* @param {string} keyword 扫描关键词。
* @return {Promise<{ orderId: number, matchType: string, cartMatchContext?: Object, waveMatchContext?: Object }>} 命中结果。
*/
async pickOrderMatchByKeyword(keyword) {
const waybillOrderId = await this.pickOrderIdByWaybill(keyword);
if (Number.isFinite(waybillOrderId) && waybillOrderId > 0) {
return {
orderId: waybillOrderId,
matchType: 'waybill',
};
}
const waveMatchContext = await this.pickWaveMatchContextByWaveNo(keyword);
const waveOrderId = Number(waveMatchContext?.order_id || 0);
if (Number.isFinite(waveOrderId) && waveOrderId > 0) {
return {
orderId: waveOrderId,
matchType: 'wave',
waveMatchContext,
};
}
const cartMatchContext = await this.pickCartMatchContextByCartCode(keyword);
const cartOrderId = Number(cartMatchContext?.order_id || 0);
if (Number.isFinite(cartOrderId) && cartOrderId > 0) {
return {
orderId: cartOrderId,
matchType: 'cart',
cartMatchContext,
};
}
throw new Error('未找到对应订单');
}
/**
* 根据运单号解析唯一订单ID。
* @param {string} waybillNo 运单号。
* @return {Promise<number>} 订单ID,未命中返回 0。
*/
async pickOrderIdByWaybill(waybillNo) {
const warehouseId = this.getWarehouseId();
const orderIds = await this.findOrderIdsByExpressNumbers([ waybillNo ], warehouseId);
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return 0;
}
const normalizedOrderIds = orderIds
.map(item => Number(item))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)
.sort((a, b) => a - b);
if (normalizedOrderIds.length === 0) {
return 0;
}
return normalizedOrderIds[0];
}
/**
* 根据车号在波次拣货任务维度反查订单ID。
* 匹配字段:任务主表当前车号快照与任务订单行车号快照。
* @param {string} cartCode 车号。
* @return {Promise<number>} 订单ID,未命中返回 0。
*/
async pickOrderIdByCartCode(cartCode) {
const cartMatchContext = await this.pickCartMatchContextByCartCode(cartCode);
const orderId = Number(cartMatchContext?.order_id || 0);
return Number.isFinite(orderId) && orderId > 0 ? orderId : 0;
}
/**
* 根据波次号查询波次信息及波次下订单列表。
* @param {string} waveNo 波次号。
* @return {Promise<{order_id:number, wave:Object|null, orders:Array<Object>, matched_order_ids:Array<number>}>} 命中上下文。
*/
async pickWaveMatchContextByWaveNo(waveNo) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const normalizedWaveNo = String(waveNo || '').trim();
if (!normalizedWaveNo) {
return {
order_id: 0,
wave: null,
orders: [],
matched_order_ids: [],
};
}
// 查询波次批次信息
const waveRows = await ctx.model.query(
`
SELECT
wave_id,
wave_no,
wave_type,
wave_status,
total_orders,
processed_orders,
creator,
create_time,
update_time
FROM wms_wave_batch
WHERE wave_no = :waveNo
AND warehouse_id = :warehouseId
ORDER BY create_time DESC, wave_id DESC
LIMIT 1
`,
{
replacements: { waveNo: normalizedWaveNo, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
if (!waveRow) {
return {
order_id: 0,
wave: null,
orders: [],
matched_order_ids: [],
};
}
const wave = {
wave_id: Number(waveRow.wave_id || 0),
wave_no: String(waveRow.wave_no || '').trim(),
wave_type: Number(waveRow.wave_type || 0),
wave_status: Number(waveRow.wave_status || 0),
total_orders: Number(waveRow.total_orders || 0),
processed_orders: Number(waveRow.processed_orders || 0),
creator: String(waveRow.creator || '').trim(),
create_time: waveRow.create_time || null,
update_time: waveRow.update_time || null,
};
// 查询波次下的订单列表
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_no: normalizedWaveNo,
warehouse_id: warehouseId,
},
attributes: [
'id',
'delivery_order_code',
'pre_delivery_order_code',
'pick_status',
'wave_id',
'wave_no',
'order_type',
'status',
'recheck_status',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const orders = (Array.isArray(orderRows) ? orderRows : []).map(row => ({
order_id: Number(row.id || 0),
delivery_order_code: String(row.delivery_order_code || row.pre_delivery_order_code || '').trim(),
pick_status: String(row.pick_status || '').trim(),
wave_id: Number(row.wave_id || 0),
wave_no: String(row.wave_no || '').trim(),
order_type: String(row.order_type || '').trim(),
status: Number(row.status || 0),
recheck_status: String(row.recheck_status || '').trim(),
}));
const matchedOrderIds = [ ...new Set(orders
.map(o => Number(o.order_id))
.filter(id => Number.isInteger(id) && id > 0)) ];
const primaryOrderId = Number(matchedOrderIds[0] || 0);
return {
order_id: Number.isFinite(primaryOrderId) && primaryOrderId > 0 ? primaryOrderId : 0,
wave,
orders,
matched_order_ids: matchedOrderIds,
};
}
/**
* 根据车号读取任务上下文及任务订单行。
* @param {string} cartCode 车号。
* @return {Promise<{order_id:number, task:Object, task_orders:Array<Object>, matched_order_ids:Array<number>}>} 命中上下文。
*/
async pickCartMatchContextByCartCode(cartCode) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
/**
* 通过车号查找匹配的拣货任务行。
* 匹配优先级:
* 1. wms_pick_task_cart_binding(车任务绑定表,unbind_time IS NULL,权威数据源)
* 2. wms_wave_pick_task.current_cart_code_snapshot / wms_wave_pick_task_order.cart_code_snapshot(快照回退兜底,
* 仅兜底该车号下不存在解绑记录的任务:绑定表为权威数据源,已解绑的任务不再回退命中,避免解绑后快照残留误匹配)
* @param {string} cartCode 车号。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 任务行,未找到返回 null。
*/
const findTaskByCartCode = async (cartCode, warehouseId) => {
// 第一优先级:车任务绑定表(权威活跃绑定数据源,unbind_time IS NULL 表示未解绑)
const bindingRows = await ctx.model.query(
`
SELECT
t.id AS task_id,
t.task_no,
t.pick_mode,
t.status,
t.review_status,
t.current_cart_code_snapshot
FROM wms_pick_task_cart_binding b
INNER JOIN wms_wave_pick_task t
ON t.id = b.task_id
WHERE b.cart_code_snapshot = :cartCode
AND b.warehouse_id = :warehouseId
AND b.unbind_time IS NULL
ORDER BY b.create_time DESC, b.id DESC
LIMIT 1
`,
{
replacements: { warehouseId, cartCode },
type: ctx.model.QueryTypes.SELECT,
}
);
if (Array.isArray(bindingRows) && bindingRows.length > 0) {
return bindingRows[0];
}
// 第二优先级(回退兜底):任务主表 + 任务订单行快照。
// 绑定表是权威数据源:该车号下存在解绑记录(unbind_time 非空)的任务不再回退命中,
// 避免解绑后任务主表/订单行快照残留导致误匹配已完成任务。
const snapshotRows = await ctx.model.query(
`
SELECT
t.id AS task_id,
t.task_no,
t.pick_mode,
t.status,
t.review_status,
t.current_cart_code_snapshot
FROM wms_wave_pick_task t
WHERE t.warehouse_id = :warehouseId
AND (
t.current_cart_code_snapshot = :cartCode
OR EXISTS (
SELECT 1
FROM wms_wave_pick_task_order pto
WHERE pto.task_id = t.id
AND pto.cart_code_snapshot = :cartCode
)
)
AND NOT EXISTS (
SELECT 1
FROM wms_pick_task_cart_binding b
WHERE b.task_id = t.id
AND b.warehouse_id = :warehouseId
AND b.cart_code_snapshot = :cartCode
AND b.unbind_time IS NOT NULL
)
ORDER BY t.create_time DESC, t.id DESC
LIMIT 1
`,
{
replacements: { warehouseId, cartCode },
type: ctx.model.QueryTypes.SELECT,
}
);
return (Array.isArray(snapshotRows) && snapshotRows.length > 0) ? snapshotRows[0] : null;
};
const taskRow = await findTaskByCartCode(cartCode, warehouseId);
const taskId = Number(taskRow && taskRow.task_id || 0);
if (!Number.isInteger(taskId) || taskId <= 0) {
return {
order_id: 0,
task: null,
task_orders: [],
matched_order_ids: [],
};
}
const pickMode = Number(taskRow.pick_mode || 0);
// 团购模式(小波次 pick_mode=1 / 大波次 pick_mode=5):
// wms_wave_pick_task_order 表无记录,直接返回 task 信息,
// 以 task_id 作为 order_id 保证 pickOrderMatchByKeyword 的 cartMatch.order_id > 0 检查通过
if (pickMode === 1 || pickMode === 5) {
const task = {
task_id: taskId,
task_no: String(taskRow.task_no || '').trim(),
pick_mode: pickMode,
status: Number(taskRow.status || 0),
review_status: Number(taskRow.review_status || 0),
current_cart_code_snapshot: String(taskRow.current_cart_code_snapshot || '').trim(),
};
return {
order_id: taskId,
task,
task_orders: [],
matched_order_ids: [],
};
}
const pickStatusSelect = taskOrderColumnSet.has('pick_status')
? 'pto.pick_status'
: 'NULL AS pick_status';
const waveIdSelect = taskOrderColumnSet.has('wave_id')
? 'pto.wave_id'
: 'NULL AS wave_id';
const boxNoSelect = taskOrderColumnSet.has('box_no')
? 'pto.box_no'
: 'NULL AS box_no';
const cartCodeSnapshotSelect = taskOrderColumnSet.has('cart_code_snapshot')
? 'pto.cart_code_snapshot'
: 'NULL AS cart_code_snapshot';
const taskOrderWarehouseFilterSql = taskOrderColumnSet.has('warehouse_id')
? ' AND pto.warehouse_id = :warehouseId'
: '';
const taskOrderRowsRaw = await ctx.model.query(
`
SELECT
pto.id AS task_order_id,
pto.order_id,
${pickStatusSelect},
${waveIdSelect},
${boxNoSelect},
${cartCodeSnapshotSelect}
FROM wms_wave_pick_task_order pto
WHERE pto.task_id = :taskId
${taskOrderWarehouseFilterSql}
ORDER BY pto.id ASC
`,
{
replacements: {
taskId,
warehouseId,
},
type: ctx.model.QueryTypes.SELECT,
}
);
const task = {
task_id: Number(taskRow.task_id || 0),
task_no: String(taskRow.task_no || '').trim(),
pick_mode: Number(taskRow.pick_mode || 0),
status: Number(taskRow.status || 0),
review_status: Number(taskRow.review_status || 0),
current_cart_code_snapshot: String(taskRow.current_cart_code_snapshot || '').trim(),
};
const taskOrderRows = (Array.isArray(taskOrderRowsRaw) ? taskOrderRowsRaw : []).map(row => ({
task_order_id: Number(row && row.task_order_id || 0),
order_id: Number(row && row.order_id || 0),
pick_status: String(row && row.pick_status || '').trim(),
wave_id: Number(row && row.wave_id || 0),
box_no: Number(row && row.box_no || 0),
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
}));
const matchedOrderIds = [ ...new Set(taskOrderRows
.map(row => Number(row && row.order_id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
const primaryOrderId = Number(matchedOrderIds[0] || 0);
return {
order_id: Number.isFinite(primaryOrderId) && primaryOrderId > 0 ? primaryOrderId : 0,
task,
task_orders: taskOrderRows,
matched_order_ids: matchedOrderIds,
};
}
/**
* 读取数据表字段集合。
* @param {string} tableName 数据表名。
* @return {Promise<Set<string>>} 字段名集合。
*/
async getTableColumnSet(tableName) {
const { ctx } = this;
const normalizedTableName = String(tableName || '').trim();
if (!normalizedTableName) {
return new Set();
}
const escapedTableName = normalizedTableName.replace(/`/g, '``');
try {
const rows = await ctx.model.query(`SHOW COLUMNS FROM \`${escapedTableName}\``, {
type: ctx.model.QueryTypes.SELECT,
});
return new Set((Array.isArray(rows) ? rows : [])
.map(row => String(row && row.Field || '').trim())
.filter(Boolean));
} catch (error) {
ctx.logger.warn(`[recheckOrder.getTableColumnSet] 获取字段失败, table=${normalizedTableName}, error=${error.message}`);
return new Set();
}
}
/**
* 解析拣货模式名称。
* @param {number|string} pickMode 拣货模式编码。
* @return {string} 拣货模式名称。
*/
resolvePickModeName(pickMode) {
const pickModeMap = {
1: '团购小波次',
2: '散单单品单件',
3: '散单先拣后分',
4: '边拣边分',
5: '团购大波次',
};
const normalizedPickMode = Number(pickMode || 0);
return pickModeMap[normalizedPickMode] || '未知模式';
}
/**
* 构建波次号命中语义化视图。
* @param {Object} waveMatchContext 波次号命中上下文。
* @return {Promise<Object>} 语义化视图。
*/
async buildWaveMatchView(waveMatchContext = {}) {
const context = this.isPlainObject(waveMatchContext) ? waveMatchContext : {};
const wave = this.isPlainObject(context.wave) ? context.wave : {};
const orders = Array.isArray(context.orders) ? context.orders : [];
return {
wave_id: Number(wave.wave_id || 0),
wave_no: String(wave.wave_no || '').trim(),
wave_type: Number(wave.wave_type || 0),
wave_status: Number(wave.wave_status || 0),
total_orders: Number(wave.total_orders || 0),
processed_orders: Number(wave.processed_orders || 0),
creator: String(wave.creator || '').trim(),
create_time: wave.create_time || null,
update_time: wave.update_time || null,
order_count: orders.length,
orders,
};
}
/**
* 构建车号命中语义化视图。
* @param {Object} cartMatchContext 车号命中上下文。
* @return {Promise<Object>} 语义化视图。
*/
async buildCartMatchView(cartMatchContext = {}) {
const context = this.isPlainObject(cartMatchContext) ? cartMatchContext : {};
const task = this.isPlainObject(context.task) ? context.task : {};
const taskOrders = Array.isArray(context.task_orders) ? context.task_orders : [];
const pickMode = Number(task.pick_mode || 0);
const modeName = this.resolvePickModeName(pickMode);
const enrichedTaskOrders = await this.enrichTaskOrderRows(taskOrders);
const taskSummary = {
task_id: Number(task.task_id || 0),
task_no: String(task.task_no || '').trim(),
pick_mode: pickMode,
status: Number(task.status || 0),
review_status: Number(task.review_status || 0),
current_cart_code_snapshot: String(task.current_cart_code_snapshot || '').trim(),
order_count: enrichedTaskOrders.length,
};
const baseView = {
mode_code: pickMode,
mode_name: modeName,
view_type: 'orders',
task: taskSummary,
};
if ([ 1, 5 ].includes(pickMode)) {
return {
...baseView,
view_type: 'groups',
groups: this.groupTaskOrdersByWaveId(enrichedTaskOrders),
};
}
if (pickMode === 2) {
return {
...baseView,
view_type: 'orders',
orders: enrichedTaskOrders,
};
}
if (pickMode === 3) {
return {
...baseView,
view_type: 'pick_groups',
pick_groups: this.groupTaskOrdersByPickStatus(enrichedTaskOrders),
};
}
if (pickMode === 4) {
return {
...baseView,
view_type: 'box_groups',
box_groups: this.groupTaskOrdersByBoxNo(enrichedTaskOrders),
};
}
return {
...baseView,
view_type: 'orders',
orders: enrichedTaskOrders,
};
}
/**
* 将车号匹配视图中的订单平铺为一维数组。
* 根据 view_type 从 groups / pick_groups / box_groups / orders 中提取所有订单。
* @param {Object} cartMatchView 车号匹配视图。
* @return {Array<Object>} 平铺后的订单列表。
*/
flattenCartMatchOrders(cartMatchView = {}) {
const view = this.isPlainObject(cartMatchView) ? cartMatchView : {};
const { view_type: viewType } = view;
if (viewType === 'groups') {
const groups = Array.isArray(view.groups) ? view.groups : [];
return groups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
if (viewType === 'pick_groups') {
const pickGroups = Array.isArray(view.pick_groups) ? view.pick_groups : [];
return pickGroups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
if (viewType === 'box_groups') {
const boxGroups = Array.isArray(view.box_groups) ? view.box_groups : [];
return boxGroups.flatMap(g => (Array.isArray(g.orders) ? g.orders : []));
}
// view_type === 'orders' 或兜底
return Array.isArray(view.orders) ? view.orders : [];
}
/**
* 追加任务订单行的订单维度字段。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Promise<Array<Object>>} 扩展后的任务订单行。
*/
async enrichTaskOrderRows(taskOrders = []) {
const warehouseId = this.getWarehouseId();
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
const orderIds = [ ...new Set(normalizedTaskOrders
.map(row => Number(row && row.order_id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
if (orderIds.length === 0) {
return [];
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: this.buildOrderWhere(orderIds, warehouseId),
attributes: [ 'id', 'wave_id', 'pick_status' ],
raw: true,
});
const orderMap = new Map((Array.isArray(orderRows) ? orderRows : [])
.map(row => [
Number(row && row.id || 0),
{
wave_id: Number(row && row.wave_id || 0),
pick_status: String(row && row.pick_status || '').trim(),
},
])
.filter(item => Number(item[0]) > 0));
return normalizedTaskOrders.map(row => {
const orderId = Number(row && row.order_id || 0);
const orderInfo = orderMap.get(orderId) || {};
const waveId = Number(row && row.wave_id || 0) > 0
? Number(row && row.wave_id || 0)
: Number(orderInfo.wave_id || 0);
const pickStatus = String(row && row.pick_status || '').trim() || String(orderInfo.pick_status || '').trim() || 'unknown';
return {
task_order_id: Number(row && row.task_order_id || 0),
order_id: orderId,
wave_id: Number.isInteger(waveId) && waveId > 0 ? waveId : 0,
pick_status: pickStatus,
box_no: Number(row && row.box_no || 0),
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
};
});
}
/**
* 按 wave_id 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} wave 分组结果。
*/
groupTaskOrdersByWaveId(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `wave_${Number(row && row.wave_id || 0)}`, row => ({
wave_id: Number(row && row.wave_id || 0),
orders: [],
}));
}
/**
* 按 pick_status 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} pick_status 分组结果。
*/
groupTaskOrdersByPickStatus(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `pick_status_${String(row && row.pick_status || 'unknown').trim() || 'unknown'}`, row => ({
pick_status: String(row && row.pick_status || 'unknown').trim() || 'unknown',
orders: [],
}));
}
/**
* 按 box_no 分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @return {Array<Object>} box_no 分组结果。
*/
groupTaskOrdersByBoxNo(taskOrders = []) {
return this.groupTaskOrders(taskOrders, row => `box_${Number(row && row.box_no || 0)}`, row => ({
box_no: Number(row && row.box_no || 0),
orders: [],
}));
}
/**
* 通用任务订单分组。
* @param {Array<Object>} taskOrders 任务订单行。
* @param {Function} keyGetter 分组键生成器。
* @param {Function} initGroup 分组初始化函数。
* @return {Array<Object>} 分组列表。
*/
groupTaskOrders(taskOrders = [], keyGetter, initGroup) {
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
const groupMap = new Map();
normalizedTaskOrders.forEach(row => {
const groupKey = String(keyGetter(row));
if (!groupMap.has(groupKey)) {
groupMap.set(groupKey, initGroup(row));
}
const group = groupMap.get(groupKey);
group.orders.push({ ...row });
});
return Array.from(groupMap.values()).map(group => ({
...group,
order_count: Array.isArray(group.orders) ? group.orders.length : 0,
}));
}
/**
* 生成复核单号。
* @param {number} orderId 订单ID。
* @param {Date} now 当前时间。
* @return {string} 复核单号。
*/
buildRecheckReviewNo(orderId, now = new Date()) {
const timestamp = Number(now.getTime());
const paddedOrderId = String(orderId).padStart(6, '0');
return `RC${timestamp}${paddedOrderId}`;
}
/**
* 校验订单是否允许复核,未拣货订单或已拦截订单不允许复核。
* @param {Object} order 订单信息。
*/
assertOrderCanRecheck(order = {}) {
if (String(order.pick_status || '') === 'none') {
throw new Error('订单未拣货,不允许复核。');
}
if (this.isInterceptedOrderStatus(order.intercept_status)) {
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 wms_order_express oe
WHERE oe.order_id = o.id
AND oe.warehouse_id = o.warehouse_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;
}
// 波次内序号筛选(wms_order_wave_index.wave_index)
// 支持 wave_index: { operator: 'between', value: [起, 止] },以及 wave_index_min / wave_index_max
const rawWaveIndexCondition = this.isPlainObject(where.wave_index) ? where.wave_index : null;
if (rawWaveIndexCondition) {
const waveIndexOperator = String(rawWaveIndexCondition.operator || 'eq').toLowerCase();
const rawWaveIndexValue = rawWaveIndexCondition.value;
if (waveIndexOperator === 'between' && Array.isArray(rawWaveIndexValue) && rawWaveIndexValue.length === 2) {
const betweenStart = Number(rawWaveIndexValue[0]);
const betweenEnd = Number(rawWaveIndexValue[1]);
if (Number.isFinite(betweenStart) && Number.isFinite(betweenEnd)) {
conditions.push('wi.wave_index BETWEEN :waveIndexBetweenStart AND :waveIndexBetweenEnd');
replacements.waveIndexBetweenStart = betweenStart;
replacements.waveIndexBetweenEnd = betweenEnd;
}
} else if ((waveIndexOperator === 'gte' || waveIndexOperator === 'ge')
&& rawWaveIndexValue !== undefined && rawWaveIndexValue !== null && rawWaveIndexValue !== '') {
const gteValue = Number(rawWaveIndexValue);
if (Number.isFinite(gteValue)) {
conditions.push('wi.wave_index >= :waveIndexGte');
replacements.waveIndexGte = gteValue;
}
} else if ((waveIndexOperator === 'lte' || waveIndexOperator === 'le')
&& rawWaveIndexValue !== undefined && rawWaveIndexValue !== null && rawWaveIndexValue !== '') {
const lteValue = Number(rawWaveIndexValue);
if (Number.isFinite(lteValue)) {
conditions.push('wi.wave_index <= :waveIndexLte');
replacements.waveIndexLte = lteValue;
}
} else if (waveIndexOperator === 'eq'
&& rawWaveIndexValue !== undefined && rawWaveIndexValue !== null && rawWaveIndexValue !== '') {
const eqValue = Number(rawWaveIndexValue);
if (Number.isFinite(eqValue)) {
conditions.push('wi.wave_index = :waveIndexEq');
replacements.waveIndexEq = eqValue;
}
}
} else {
const rawWaveIndexMin = this.isPlainObject(where.wave_index_min)
? where.wave_index_min.value
: where.wave_index_min;
if (rawWaveIndexMin !== undefined && rawWaveIndexMin !== null && rawWaveIndexMin !== '') {
const waveIndexMin = Number(rawWaveIndexMin);
if (Number.isFinite(waveIndexMin)) {
conditions.push('wi.wave_index >= :waveIndexMin');
replacements.waveIndexMin = waveIndexMin;
}
}
const rawWaveIndexMax = this.isPlainObject(where.wave_index_max)
? where.wave_index_max.value
: where.wave_index_max;
if (rawWaveIndexMax !== undefined && rawWaveIndexMax !== null && rawWaveIndexMax !== '') {
const waveIndexMax = Number(rawWaveIndexMax);
if (Number.isFinite(waveIndexMax)) {
conditions.push('wi.wave_index <= :waveIndexMax');
replacements.waveIndexMax = waveIndexMax;
}
}
}
// stock_query 商品模糊筛选:通过 stock_warehouse / stock_barcodes → order_items → order_id
const stockQuery = String(where.stock_query || '').trim();
if (stockQuery) {
const stockOrderIds = await this.findOrderIdsByStockQuery(stockQuery, 'order', warehouseId);
if (stockOrderIds.length > 0) {
conditions.push('o.id IN (:stockOrderIds)');
replacements.stockOrderIds = stockOrderIds;
} else {
// 未匹配到任何商品,直接返回空列表
return this.success('ok', {
list: [],
pagination: {
page,
pageSize,
total: 0,
totalPages: 0,
hasPrevious: false,
hasNext: false,
},
});
}
}
const whereClause = conditions.length > 0
? `WHERE ${conditions.join('\n AND ')}`
: '';
const waveIndexJoin = `
LEFT JOIN wms_order_wave_index wi
ON wi.warehouse_id = o.warehouse_id
AND wi.order_id = o.id`;
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.packages_weight,
o.weight_type,
o.status,
o.create_at,
o.recheck_time,
o.has_sn_item,
wi.wave_index,
(SELECT oe.waybill_code FROM wms_order_express oe WHERE oe.order_id = o.id AND oe.warehouse_id = o.warehouse_id AND oe.delete_at IS NULL LIMIT 1) AS waybill_code
FROM ${orderTableName} o${waveIndexJoin}
${whereClause}
ORDER BY o.id ASC
LIMIT :limit OFFSET :offset
`;
const countSql = `
SELECT COUNT(1) AS total
FROM ${orderTableName} o${waveIndexJoin}
${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,
packages_weight: row?.packages_weight != null ? Number(row.packages_weight) : null,
weight_type: this.formatWeightTypeLabel(row?.weight_type),
waybill_code: String(row?.waybill_code || '').trim(),
wave_index: Number(row?.wave_index || 0),
status: Number(row?.status || 0),
create_at: row?.create_at || null,
recheck_time: row?.recheck_time || null,
has_sn_item: String(row?.has_sn_item || '').trim().toUpperCase() === 'Y' ? 'Y' : 'N',
}));
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;
}
// stock_query 商品模糊筛选:通过 stock_warehouse / stock_barcodes → order_items → order_id 过滤波次
const stockQuery = String(where.stock_query || '').trim();
if (stockQuery) {
const stockOrderIds = await this.findOrderIdsByStockQuery(stockQuery, 'order', warehouseId);
if (stockOrderIds.length > 0) {
conditions.push('o.id IN (:stockOrderIds)');
replacements.stockOrderIds = stockOrderIds;
} else {
// 未匹配到任何商品,直接返回空列表
return this.success('ok', {
list: [],
pagination: {
page,
pageSize,
total: 0,
totalPages: 0,
hasPrevious: false,
hasNext: false,
},
});
}
}
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 列表直接匹配订单,批量将其拦截状态更新为"仓库拦截成功"。
* 仅拦截当前指定订单(不波及波次内其他订单),支持部分失败:未找到的订单与处理失败的
* 订单记录在 failed 列表并返回失败原因,其余订单继续处理。
*
* 本方法为 method 出口包装层:解析仓库上下文与订单ID后,复用 systems 层
* interceptAutoConfirm.confirmInterceptForOrderIds 完成实际拦截确认动作,
* 与定时任务「自动库内拦截确定」共用同一内部实现,保证两条链路行为一致。
*
* 前置条件:订单必须处于拦截发起中状态(requested/requesting/intercepting,历史值 intercepted 兼容)。
* 未发起拦截(none/空)的订单直接静默跳过不参与处理;已确认拦截(intercepted_at_warehouse)及其它
* 非可确认状态(intercepted_in_transit/returning/returned/delivered_by_mistake/timeout/cancelled/failed/
* exception)的订单一律跳过并记录失败原因;更新 SQL 的 where 同时限定拦截状态,防止并发修改导致误更新。
*
* 每个订单的拦截处理:
* 1. 更新 wms_order_delivery:intercept_status = intercepted_at_warehouse、step=4、outbound_status=fin,
* 并同步写入拦截时间 intercept_time(当前时间)
* 2. 同步更新运单表:is_intercept='Y'、is_back='Y'(库内拦截确认,货物在库内需退回)
* 3. 释放储位分配(cancelAllocateStorage 拦截模式:库存不归还可用,移入拦截锁定字段 intercept_locked_quantity)
* 4. 释放订单锁(lock_status='none')
* 5. 写入操作日志(ORDER_INTERCEPT_CONFIRM)
* 全部订单处理完后,按成功订单 ID 汇总批量创建售后工单 + 通知快递群。
* 运单标记、储位释放、锁释放、工单创建、日志写入失败均不影响主流程。
*
* @param {Object} data 请求体。
* @param {number[]|string} data.ids 订单 ID 列表,支持数组或以逗号分隔的字符串(兼容 id/order_id/orderId 单值写法)。
* @return {Promise<Object>} 批量拦截结果,包含 success/failed 列表与 success_count/failed_count 计数。
*/
async confirmIntercept(data = {}) {
const warehouseId = this.getWarehouseId();
const orderIds = this.normalizeOrderIds(data);
if (orderIds.length === 0) {
this.ctx.throw(400, '订单ID列表不能为空');
}
// method 出口仅做入参解构与包装,拦截确认动作统一由 systems 层内部方法执行
const operator = this.getOrderLogOperator();
return await this.ctx.service.systems.interceptAutoConfirm.confirmInterceptForOrderIds({
orderIds,
warehouseId,
operator,
});
}
/**
* 拦截扫描:通过运单号查找运单记录,标记退回与拦截并处理关联工单与订单拦截状态。
*
* 处理流程:
* 1. 根据运单号查询 wms_order_express;运单不存在,或运单 is_intercept≠'Y' 且关联订单
* intercept_status 不在 requested/intercepting 时,视为非拦截订单并拒绝
* 2. 校验通过后将运单 is_back、is_intercept 设为 'Y'
* 3. 检查是否存在关联的未完结售后工单(wms_after_sale),若有则调用 handleWorkOrder 写入
* "库内拦截成功"步骤并将工单置为 completed
* 4. 同步更新 wms_order_delivery 的 intercept_status 为 intercepted_at_warehouse(**不写 intercept_time**:
* 该字段恒为「最近一次发起拦截的通知时刻」,库内确定拦截不覆盖,见 app/lib/intercept_time.js;
* 库内确定拦截时刻以配送表 dispath_time 为准),
* 并释放储位分配(拦截模式:库存移入拦截锁定,不归还可用)与订单锁(仅订单级状态更新,不标记订单下其他面单)
*
* 注:库内拦截确认需标记退回 is_back='Y';发起拦截链路仅写 is_intercept,不写 is_back。
*
* @param {Object} data 请求体。
* @param {string} data.waybill_code 运单号。
* @return {Promise<Object>} 拦截扫描结果,包含 waybill_code、is_back、is_intercept、after_sale(若有)、order。
*/
async interceptScan(data = {}) {
const { ctx, service } = this;
const { waybill_code: waybillCode } = data || {};
if (!waybillCode || !String(waybillCode).trim()) {
throw new Error('运单号不能为空');
}
const normalizedWaybillCode = String(waybillCode).trim();
const warehouseId = this.getWarehouseId();
const now = new Date();
// 1. 查询运单记录
const expressRecord = await ctx.model.OrderExpress.findOne({
where: { waybill_code: normalizedWaybillCode, warehouse_id: warehouseId },
raw: true,
});
// 1a. 非拦截订单校验:运单不存在,或运单/关联订单均未发起系统拦截,则拒绝
if (!expressRecord) {
throw new Error('非拦截订单');
}
const expressIntercepted = String(expressRecord.is_intercept || '').trim() === 'Y';
let orderIntercepted = false;
if (!expressIntercepted) {
const linkedOrderId = Number(expressRecord.order_id || 0);
if (linkedOrderId > 0) {
const checkOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const linkedOrder = await checkOrderModel.findOne({
where: this.buildOrderWhere([ linkedOrderId ], warehouseId),
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
orderIntercepted = linkedOrder
? [ 'requested', 'intercepting' ].includes(String(linkedOrder.intercept_status || '').trim())
: false;
}
}
if (!expressIntercepted && !orderIntercepted) {
throw new Error('非拦截订单');
}
// 2. 标记退回 + 拦截
await ctx.model.OrderExpress.update(
{ is_back: 'Y', is_intercept: 'Y' },
{ where: { id: expressRecord.id } }
);
// 3. 检查关联的未完结售后工单
const afterSale = await ctx.model.AfterSale.findOne({
where: {
waybill_no: normalizedWaybillCode,
warehouse_id: warehouseId,
deleted_at: null,
status: { [ctx.app.Sequelize.Op.notIn]: [ 'completed', 'closed', 'cancelled' ] },
},
order: [[ 'id', 'DESC' ]],
raw: true,
});
let afterSaleResult = null;
if (afterSale) {
const operator = this.getOrderLogOperator();
const operatorId = operator.id ? Number(operator.id) : 0;
const operatorSnapshot = JSON.stringify({
id: String(operator.id || ''),
name: String(operator.name || ''),
});
try {
afterSaleResult = await service.systems.afterSale.handleWorkOrder({
id: afterSale.id,
remark: '库内拦截成功',
targetStatus: 'completed',
resolution: '库内拦截成功',
attachmentIds: [],
operatorId,
operatorSnapshot,
warehouseId,
});
} catch (workOrderErr) {
ctx.logger.warn(
`[recheckOrder.interceptScan] 处理工单失败, afterSaleId=${afterSale.id}, waybill=${normalizedWaybillCode}, error=${workOrderErr.message}`
);
// 工单处理失败不阻断主流程
}
}
// 4. 更新订单拦截状态(与 confirmIntercept 一致:订单级拦截,覆盖所有面单含子面单)
const orderId = Number(expressRecord.order_id || 0);
let orderResult = null;
if (orderId > 0) {
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' ],
raw: true,
});
if (order) {
// 库内确定拦截不写 intercept_time(不覆盖通知拦截时刻),库内确定时刻以配送表 dispath_time 为准
await orderModel.update(
{
intercept_status: 'intercepted_at_warehouse',
step: 4,
outbound_status: 'fin',
updated_at: now,
},
{ where: orderWhere }
);
// 释放储位分配(拦截模式:库存移入拦截锁定,不归还可用)
try {
await service.systems.orderStorageAllocation.cancelAllocateStorage({
order_ids: [ orderId ],
interceptMode: true,
});
} catch (allocErr) {
ctx.logger.warn(
`[recheckOrder.interceptScan] 释放储位分配失败, orderId=${orderId}, error=${allocErr.message}`
);
}
// 释放订单锁
try {
await orderModel.update(
{ lock_status: 'none', updated_at: now },
{ where: orderWhere }
);
} catch (lockErr) {
ctx.logger.warn(
`[recheckOrder.interceptScan] 释放锁失败, 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: orderId,
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.interceptScan] 写入操作日志失败, orderId=${orderId}, error=${logErr.message}`
);
}
orderResult = {
order_id: orderId,
order_no: orderNo,
intercept_status: 'intercepted_at_warehouse',
};
}
}
return {
waybill_code: normalizedWaybillCode,
is_back: 'Y',
is_intercept: 'Y',
after_sale: afterSaleResult ? afterSaleResult.after_sale : null,
order: orderResult,
};
}
/**
* 批量快捷复核:对一批订单 IDs 依次执行前置条件检查与复核流程。
* 支持部分失败:不满足前置条件的订单直接跳过并记录失败原因,其余订单继续走完拣货完成 + 复核标记流程。
*
* 前置条件(任一不满足即跳过):
* 1. 未分配储位:storage_status 不等于 'fin'
* 2. 未分配快递:post_status 不等于 'fin'
* 3. 未同步:status 不等于 'created'
* 4. 已拦截:intercept_status 处于拦截流程状态(requested/requesting/intercepting/intercepted_in_transit/intercepted_at_warehouse,历史值 intercepted 兼容)
*
* 核心流程(每个满足条件的订单在独立事务中执行):
* 1. 若 pick_status 不等于 'fin',先完成拣货:
* - 更新 wms_wave_pick_task_order 拣货状态(仅当订单关联拣货任务时)
* - 更新 wms_order_delivery.pick_status = 'fin'
* - 更新 wms_picking.status = 'fin'(仅当存在拣货记录时)
* - 汇总 wms_picking 中各 storage_id 的 quantity,扣减 wms_storage.locked_quantity 与 quantity
* - 写入 wms_storage_transaction 出库流水
* 2. 标记复核:
* - 更新 wms_order_delivery.recheck_status = 'fin'、recheck_time = now
* - 插入 wms_recheck_task 复核记录
* - 更新 wms_wave_pick_task_order 复核状态并尝试解绑车任务
* - 写入操作日志
*
* @param {Object} data 请求体。
* @param {number[]|string} data.ids 订单 ID 列表,支持数组或以逗号分隔的字符串。
* @return {Promise<Object>} 批量复核结果,包含 success、failed、success_count、failed_count。
*/
async batchQuickRecheck(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const orderIds = this.normalizeOrderIds(data);
if (orderIds.length === 0) {
this.ctx.throw(400, '订单ID列表不能为空');
}
// ── 1. 批量查询所有订单的当前状态 ──
const orderModel = await this.getOrderModel('order', warehouseId);
const orderRows = await orderModel.findAll({
where: this.buildOrderWhere(orderIds, warehouseId),
attributes: [
'id', 'delivery_order_code', 'pre_delivery_order_code',
'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status',
'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item',
],
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;
}
if (this.isInterceptedOrderStatus(order.intercept_status)) {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '已拦截',
});
continue;
}
const storageStatus = String(order.storage_status || '').trim();
if (storageStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '未分配储位',
});
continue;
}
const postStatus = String(order.post_status || '').trim();
if (postStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有分配快递',
});
continue;
}
const syncStatus = String(order.sync_status || '').trim();
if (syncStatus !== 'fin') {
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有同步',
});
continue;
}
validOrders.push(order);
}
// ── 3. 逐订单在独立事务中执行拣货完成 + 复核标记 ──
const successOrders = [];
for (const order of validOrders) {
const orderId = Number(order.id);
try {
await ctx.model.transaction(async transaction => {
// 3a. 若未完成拣货,先执行拣货完成流程
const pickStatus = String(order.pick_status || '').trim();
if (pickStatus !== 'fin') {
await this._completePickForOrder(orderId, warehouseId, transaction);
// 更新内存中的 pick_status,避免后续 assertOrderCanRecheck 因旧值误判
order.pick_status = 'fin';
}
// 3b. 标记复核
await this._markRecheckForOrder(order, warehouseId, transaction);
});
successOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
});
} catch (error) {
ctx.logger.warn(
`[batchQuickRecheck] 订单复核失败, orderId=${orderId}, error=${error.message}`
);
failedOrders.push({
order_id: orderId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: `复核失败: ${error.message}`,
});
}
}
// 通知仓库面板刷新(大屏增量更新,失败不影响主流程)
await this.service.systems.warehousePanel.touchLastChangeAt(Number(warehouseId));
return {
success: successOrders,
failed: failedOrders,
success_count: successOrders.length,
failed_count: failedOrders.length,
};
}
/**
* 规范波次 ID 入参,兼容 wave_ids、waveIds、wave_id 等写法。
* @param {Object} data 请求体。
* @return {number[]} 波次 ID 列表。
*/
normalizeWaveIds(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const rawIds = requestData.wave_ids;
const sourceIds = [];
if (Array.isArray(rawIds)) {
sourceIds.push(...rawIds);
} else if (typeof rawIds === 'string') {
sourceIds.push(...rawIds.split(','));
} else if (rawIds !== undefined && rawIds !== null && rawIds !== '') {
sourceIds.push(rawIds);
} else if (requestData.waveIds !== undefined && requestData.waveIds !== null && requestData.waveIds !== '') {
const val = requestData.waveIds;
if (Array.isArray(val)) sourceIds.push(...val);
else if (typeof val === 'string') sourceIds.push(...val.split(','));
else sourceIds.push(val);
} else if (requestData.wave_id !== undefined && requestData.wave_id !== null && requestData.wave_id !== '') {
sourceIds.push(requestData.wave_id);
}
const normalizedIds = [];
for (const value of sourceIds) {
const normalizedId = Number(String(value).trim());
if (Number.isFinite(normalizedId) && normalizedId > 0) {
normalizedIds.push(normalizedId);
}
}
return Array.from(new Set(normalizedIds));
}
/**
* 按波次批量快捷复核:传入波次 IDs 列表,对每个波次下所有有效订单执行前置检查
* (已分配储位、已分配快递、已同步且未被拦截),必要时自动完成拣货(含库存锁定校验与扣减、
* 库存流水写入、拣货任务状态同步)后标记复核(含复核任务记录、任务复核状态更新、车任务解绑、
* 操作日志)。每个订单在独立事务中执行,支持部分失败,不满足条件的订单跳过并返回原因。
*
* @param {Object} data 请求体。
* @param {number[]|string} [data.wave_ids] 波次 ID 列表,支持数组或以逗号分隔的字符串。
* @param {number[]|string} [data.waveIds] 波次 ID 列表别名(驼峰写法)。
* @param {number} [data.wave_id] 单个波次 ID。
* @return {Promise<Object>} 处理结果,包含 success/failed 列表及计数。
*/
async batchQuickRecheckByWave(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const waveIds = this.normalizeWaveIds(data);
if (waveIds.length === 0) {
this.ctx.throw(400, '波次ID列表不能为空');
}
// ── 1. 批量查询所有波次下的订单 ──
const orderModel = await this.getOrderModel('order', warehouseId);
const orderRows = await orderModel.findAll({
where: {
wave_id: { [this.app.Sequelize.Op.in]: waveIds },
warehouse_id: warehouseId,
},
attributes: [
'id', 'delivery_order_code', 'pre_delivery_order_code',
'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status',
'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item',
],
raw: true,
});
// 按 wave_id 分组
const waveOrderMap = new Map();
for (const row of orderRows) {
const wid = Number(row.wave_id);
if (!waveOrderMap.has(wid)) {
waveOrderMap.set(wid, []);
}
waveOrderMap.get(wid).push(row);
}
// ── 2. 前置条件检查:逐波次、逐订单校验 ──
const allSuccessOrders = [];
const allFailedOrders = [];
for (const waveId of waveIds) {
const waveOrders = waveOrderMap.get(waveId) || [];
if (waveOrders.length === 0) {
allFailedOrders.push({
wave_id: waveId,
reason: '波次下无订单',
});
continue;
}
const validOrders = [];
for (const order of waveOrders) {
const orderId = Number(order.id);
if (this.isInterceptedOrderStatus(order.intercept_status)) {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '已拦截',
});
continue;
}
const storageStatus = String(order.storage_status || '').trim();
if (storageStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '未分配储位',
});
continue;
}
const postStatus = String(order.post_status || '').trim();
if (postStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有分配快递',
});
continue;
}
const syncStatus = String(order.sync_status || '').trim();
if (syncStatus !== 'fin') {
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: '没有同步',
});
continue;
}
validOrders.push(order);
}
// ── 3. 逐订单在独立事务中执行拣货完成 + 复核标记 ──
for (const order of validOrders) {
const orderId = Number(order.id);
try {
await ctx.model.transaction(async transaction => {
// 3a. 若未完成拣货,先执行拣货完成流程
const pickStatus = String(order.pick_status || '').trim();
if (pickStatus !== 'fin') {
await this._completePickForOrder(orderId, warehouseId, transaction);
// 更新内存中的 pick_status,避免后续 _markRecheckForOrder 因旧值误判
order.pick_status = 'fin';
}
// 3b. 标记复核
await this._markRecheckForOrder(order, warehouseId, transaction);
});
allSuccessOrders.push({
order_id: orderId,
wave_id: Number(order.wave_id) || waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
});
} catch (error) {
ctx.logger.warn(
`[batchQuickRecheckByWave] 订单复核失败, orderId=${orderId}, waveId=${waveId}, error=${error.message}`
);
allFailedOrders.push({
order_id: orderId,
wave_id: waveId,
delivery_order_code: String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(),
reason: `复核失败: ${error.message}`,
});
}
}
}
// 通知仓库面板刷新(大屏增量更新,失败不影响主流程)
await this.service.systems.warehousePanel.touchLastChangeAt(Number(warehouseId));
return {
success: allSuccessOrders,
failed: allFailedOrders,
success_count: allSuccessOrders.length,
failed_count: allFailedOrders.length,
};
}
/**
* 完成单个订单的拣货流程(内部方法,在事务中执行)。
* 包含:更新拣货任务订单状态、订单拣货状态、拣货记录状态、扣减库存锁定数量与可用数量、写库存流水。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _completePickForOrder(orderId, warehouseId, transaction) {
const { ctx, app } = this;
// 步骤1:若订单关联拣货任务,更新 wms_wave_pick_task_order 的拣货状态
const taskOrderRows = await ctx.model.query(
`SELECT id, task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
LIMIT 1`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const hasTaskOrder = Array.isArray(taskOrderRows) && taskOrderRows.length > 0;
if (hasTaskOrder) {
await ctx.model.query(
`UPDATE wms_wave_pick_task_order
SET pick_status = 1,
picked_time = NOW(),
update_time = NOW()
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
// 步骤2:更新 wms_order_delivery.pick_status = 'fin'
const orderModel = await this.getOrderModel('order', warehouseId);
await orderModel.update(
{ pick_status: 'fin' },
{
where: this.buildOrderWhere([ orderId ], warehouseId),
transaction,
validate: false,
hooks: false,
}
);
// 步骤3:检查是否存在 wms_picking 记录(仅统计 pending 且未删除的记录)
// 使用 FOR UPDATE 行锁,防止并发事务读取到相同的 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
AND status = 'pending'
AND deleted_at IS NULL
FOR UPDATE`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
if (normalizedPickingRows.length > 0) {
// 更新 wms_picking.status = 'fin'(仅更新 pending 且未删除的记录)
await ctx.model.query(
`UPDATE wms_picking
SET status = 'fin', updated_at = NOW()
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
AND status = 'pending'
AND deleted_at IS NULL`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
// 步骤4:汇总各 storage_id 的 quantity,扣减 wms_storage 锁定数量与可用数量
const storageQtyMap = new Map();
for (const row of normalizedPickingRows) {
const sid = Number(row.storage_id);
if (!sid || sid <= 0) continue;
const currentQty = storageQtyMap.get(sid) || 0;
storageQtyMap.set(sid, currentQty + (Number(row.quantity) || 0));
}
const storageIds = Array.from(storageQtyMap.keys());
if (storageIds.length > 0) {
// 加行锁查询当前库存
const storageRows = await ctx.model.Storage.findAll({
where: {
id: { [app.Sequelize.Op.in]: storageIds },
warehouse_id: warehouseId,
},
attributes: [
'id', 'locked_quantity', 'quantity',
'store_id', 'stock_id', 'batch_no', 'inventory_type', 'space_id',
],
lock: transaction.LOCK.UPDATE,
raw: true,
transaction,
});
// 校验锁定数量是否足够
for (const sRow of storageRows) {
const sid = Number(sRow.id);
const deduction = storageQtyMap.get(sid) || 0;
const locked = Number(sRow.locked_quantity) || 0;
if (locked < deduction) {
throw new Error(
`库存记录 ${sid} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`
);
}
}
// 构建 CASE WHEN 批量扣减
const summaryEntries = Array.from(storageQtyMap.entries());
const caseClauses = summaryEntries
.map(([ sid, qty ]) => `WHEN ${sid} THEN ${qty}`)
.join(' ');
await ctx.model.query(
`UPDATE wms_storage
SET locked_quantity = locked_quantity - CASE id ${caseClauses} END,
quantity = quantity - CASE id ${caseClauses} END,
updated_at = NOW()
WHERE id IN (:storageIds)
AND warehouse_id = :warehouseId`,
{
replacements: { storageIds, warehouseId },
transaction,
}
);
// 写入 wms_storage_transaction 出库流水
const operator = this.getOrderLogOperator();
const operatorId = String(operator.id || '').trim();
const operatorName = String(operator.name || 'system').trim();
const transactionRows = [];
for (const sRow of storageRows) {
const sid = Number(sRow.id);
const deduction = storageQtyMap.get(sid) || 0;
if (deduction <= 0) continue;
const beforeQty = Number(sRow.quantity) || 0;
const beforeLocked = Number(sRow.locked_quantity) || 0;
transactionRows.push({
transaction_type: 'OUTBOUND',
warehouse_id: warehouseId,
store_id: Number(sRow.store_id) || 0,
stock_id: Number(sRow.stock_id) || 0,
storage_id: sid,
space_id: Number(sRow.space_id) || null,
quantity: deduction,
before_quantity: beforeQty,
after_quantity: Math.max(0, beforeQty - deduction),
before_locked_quantity: beforeLocked,
after_locked_quantity: Math.max(0, beforeLocked - deduction),
batch_no: sRow.batch_no || null,
inventory_type: sRow.inventory_type || 'ZP',
order_type: 'PICK_OUTBOUND',
order_no: String(orderId),
order_id: orderId,
source_order_codes: String(orderId),
operator_id: operatorId,
operator_name: operatorName,
remark: '拣货完成出库(批量快捷复核)',
created_at: new Date(),
});
}
if (transactionRows.length > 0) {
await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction });
}
}
}
// 写入 order_operation_log 拣货完成日志(双写)
try {
const operationLogService = ctx.service
&& ctx.service.systems
&& ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logOperator = this.getOrderLogOperator();
const operatorId = String(logOperator.id || '').trim();
const operatorName = String(logOperator.name || 'system').trim();
await operationLogService.createOperationLogs([
{
businessType: 'order',
businessId: `${orderId}`,
operationCode: 'ORDER_PICK_COMPLETE',
operator: { id: operatorId || null, name: operatorName || 'system' },
extras: {
message: `订单${orderId}拣货完成`,
warehouseId: Number(warehouseId),
externalLogType: 'API',
},
},
], { transaction });
}
} catch (e) {
ctx.logger.warn(
`[_completePickForOrder] order_operation_log 写入失败, orderId=${orderId}, error=${e.message}`
);
}
// 步骤5:更新 wms_wave_pick_task 状态
if (hasTaskOrder) {
const taskId = Number(taskOrderRows[0]?.task_id || 0);
if (taskId > 0) {
// 检查该任务下是否所有订单都已完成拣货
const taskOrderCount = await ctx.model.query(
`SELECT COUNT(*) AS cnt
FROM wms_wave_pick_task_order
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND pick_status != 1`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const allPicked = (Number(taskOrderCount[0]?.cnt || 0)) === 0;
if (allPicked) {
// 全部完成 → 任务状态设为已完成
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET status = 2,
finish_time = NOW(),
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
} else {
// 未全部完成 → 任务状态推进为拣货中(若仍为未开始)
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET status = CASE WHEN status = 0 THEN 1 ELSE status END,
start_time = CASE WHEN start_time IS NULL THEN NOW() ELSE start_time END,
update_time = NOW()
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
}
}
}
/**
* 标记单个订单为已复核(内部方法,在事务中执行)。
* 包含:更新订单复核状态、插入复核任务记录、更新拣货任务复核状态并尝试解绑车任务、写操作日志。
*
* @param {Object} order 订单信息行。
* @param {number} warehouseId 仓库ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _markRecheckForOrder(order, warehouseId, transaction) {
const { ctx } = this;
const orderId = Number(order.id);
// 校验订单是否允许复核(拣货已完成且未被拦截)
this.assertOrderCanRecheck(order);
// SN 订单必须逐单提交 SN 码,快捷复核没有 SN 采集入口,直接拒绝避免绕过 SN 校验
if (this.isSnOrderRow(order)) {
throw new Error('SN订单需在单订单复核中提交SN码,不支持快捷复核');
}
const now = new Date();
// 更新订单复核状态
const orderModel = await this.getOrderModel('order', warehouseId);
await orderModel.update(
{
recheck_status: 'fin',
print_status: 'fin',
recheck_time: now,
updated_at: now,
},
{
where: this.buildOrderWhere([ orderId ], warehouseId),
transaction,
validate: false,
hooks: false,
}
);
// 插入 wms_recheck_task 复核记录
const operator = this.getOrderLogOperator();
const reviewNo = this.buildRecheckReviewNo(orderId, now);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const operatorNo = String(operator.id || '').trim();
const operatorName = String(operator.name || '').trim();
await ctx.model.query(
`INSERT INTO wms_recheck_task (
review_no,
warehouse_id,
order_id,
order_no,
waybill_no,
task_status,
scan_status,
review_emp_no,
review_emp_name,
scan_emp_no,
scan_emp_name,
scan_time,
finish_time,
remark
) VALUES (
:reviewNo,
:warehouseId,
:orderId,
:orderNo,
:waybillNo,
:taskStatus,
:scanStatus,
:reviewEmpNo,
:reviewEmpName,
:scanEmpNo,
:scanEmpName,
:scanTime,
:finishTime,
:remark
)`,
{
replacements: {
reviewNo,
warehouseId,
orderId,
orderNo,
waybillNo: '',
taskStatus: 2,
scanStatus: 1,
reviewEmpNo: operatorNo,
reviewEmpName: operatorName,
scanEmpNo: operatorNo,
scanEmpName: operatorName,
scanTime: now,
finishTime: now,
remark: '系统复核完成(批量快捷复核)',
},
type: ctx.model.QueryTypes.INSERT,
transaction,
}
);
// 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务
await this._updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction);
// 写入操作日志
await this._writeRecheckActionLogInTransaction({
orderId,
warehouseId,
operator,
now,
transaction,
});
// 散单复核完成后,在事务内检查订单所属波次下所有订单是否均已复核完成,
// 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失
await this._tryCompleteWaveInTransaction(orderId, order.wave_id, warehouseId, operator, now, transaction);
}
/**
* 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成,
* 若全部完成则更新 wms_wave_batch.wave_status = 5(复核完成),
* 使该波次从 batchList 中自然消失。
*
* @param {number} orderId 当前复核的订单ID。
* @param {number|string|null} waveId 订单所属波次ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @return {Promise<void>} 无返回值。
*/
async _tryCompleteWaveIfAllOrdersRechecked(orderId, waveId, warehouseId, operator, now) {
const { ctx } = this;
const normalizedWaveId = Number(waveId);
if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) {
return;
}
// 查询波次下是否还有未复核的订单(recheck_status != 'fin')
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const unreviewedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
});
if (unreviewedCount > 0) {
return;
}
// 波次下所有订单均已复核完成,查询已完成订单数并更新波次状态
const processedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: 'fin',
},
});
const operatorName = String(operator.name || operator.id || '').trim();
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = 5,
check_operator = :operatorName,
check_time = :now,
processed_orders = :processedCount,
update_time = :now
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId`,
{
replacements: {
waveId: normalizedWaveId,
warehouseId,
operatorName,
processedCount,
now,
},
type: ctx.model.QueryTypes.UPDATE,
}
);
ctx.logger.info(
`[confirmRecheck] 波次复核完成, waveId=${normalizedWaveId}, orderId=${orderId}, processedCount=${processedCount}`
);
}
/**
* 在事务内检查订单所属波次下所有订单是否均已复核完成,
* 若全部完成则更新 wms_wave_batch.wave_status = 5(复核完成)。
* 用于批量快捷复核(batchQuickRecheck)事务内的散单路径。
*
* @param {number} orderId 当前复核的订单ID。
* @param {number|string|null} waveId 订单所属波次ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
* @param {Date} now 当前时间。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _tryCompleteWaveInTransaction(orderId, waveId, warehouseId, operator, now, transaction) {
const { ctx } = this;
const normalizedWaveId = Number(waveId);
if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) {
return;
}
// 在事务内查询波次下是否还有未复核的订单(recheck_status != 'fin')
const orderModel = await this.getOrderModel('order', warehouseId);
const unreviewedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' },
},
transaction,
});
if (unreviewedCount > 0) {
return;
}
// 波次下所有订单均已复核完成,查询已完成订单数并更新波次状态
const processedCount = await orderModel.count({
where: {
wave_id: normalizedWaveId,
warehouse_id: warehouseId,
recheck_status: 'fin',
},
transaction,
});
const operatorName = String(operator.name || operator.id || '').trim();
await ctx.model.query(
`UPDATE wms_wave_batch
SET wave_status = 5,
check_operator = :operatorName,
check_time = :now,
processed_orders = :processedCount,
update_time = :now
WHERE wave_id = :waveId
AND warehouse_id = :warehouseId`,
{
replacements: {
waveId: normalizedWaveId,
warehouseId,
operatorName,
processedCount,
now,
},
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
ctx.logger.info(
`[batchQuickRecheck] 波次复核完成, waveId=${normalizedWaveId}, orderId=${orderId}, processedCount=${processedCount}`
);
}
/**
* 将波次内「已拦截且未打印」的订单移除出波次(回池)。
*
* 背景:拦截订单无法打印、无法复核,会卡住波次复核完成判定与波次终结;
* 解除拦截后因 wave_id 仍大于 0 而无法被波次策略重新抓取,导致无法继续发货。
* 复核链路在更新复核状态后调用本方法,把未打印的拦截订单从波次中释放回候选池,
* 拦截解除后即可重新抓取发货;已打印(print_status != 'none')的拦截订单保持不动,
* 避免已贴面单实物与波次记录分离。
*
* @param {Object} params 移除参数。
* @param {number} params.waveId 波次ID。
* @param {number} params.warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
* @param {Object} [params.transaction] Sequelize 事务对象(事务内调用时传入)。
* @return {Promise<{removed_order_ids: number[], removed_count: number}>} 移除结果。
*/
async removeUnprintedInterceptedOrdersFromWave({ waveId, warehouseId, operator, transaction = null } = {}) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWaveId) || normalizedWaveId <= 0
|| !Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return { removed_order_ids: [], removed_count: 0 };
}
// 查询波次内「已拦截且未打印」的订单(intercept_status 空值按 none 处理,Op.ne 对 NULL 不命中)
const orderModel = await this.getOrderModelByTableType('current', normalizedWarehouseId);
const removableRows = await orderModel.findAll({
where: {
warehouse_id: normalizedWarehouseId,
wave_id: normalizedWaveId,
print_status: 'none',
intercept_status: { [this.app.Sequelize.Op.ne]: 'none' },
},
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
transaction,
});
const normalizedRemovableRows = Array.isArray(removableRows) ? removableRows : [];
const removedOrderIds = [ ...new Set(normalizedRemovableRows
.map(row => Number(row && row.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
if (removedOrderIds.length === 0) {
return { removed_order_ids: [], removed_count: 0 };
}
// 1. 订单 wave_id 清零(回池),清空波次编号与策略扫描标记
await orderModel.update({
wave_id: 0,
wave_no: '',
wave_strategy_version: 0,
wave_scan_result: 0,
}, {
where: {
warehouse_id: normalizedWarehouseId,
id: { [this.app.Sequelize.Op.in]: removedOrderIds },
},
transaction,
validate: false,
hooks: false,
});
// 2. 删除波次索引行(其余订单 wave_index 保持不变仅跳号,避免与已放货篮子编号错位)
const waveService = ctx.service && ctx.service.systemMethods && ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.deleteOrderWaveIndexByOrderIds === 'function') {
await waveService.deleteOrderWaveIndexByOrderIds({
warehouseId: normalizedWarehouseId,
orderIds: removedOrderIds,
transaction,
});
}
// 3. 移除任务订单关联(散单模式),任务复核完成判定与进度统计不再包含拦截订单
await ctx.model.query(
`DELETE FROM wms_wave_pick_task_order
WHERE warehouse_id = :warehouseId
AND order_id IN (:orderIds)`,
{
replacements: {
warehouseId: normalizedWarehouseId,
orderIds: removedOrderIds,
},
transaction,
}
);
// 4. 回写波次统计:total_orders 扣除被移除订单数,processed_orders 收敛不超过剩余订单数
const remainingRows = await orderModel.findAll({
where: {
warehouse_id: normalizedWarehouseId,
wave_id: normalizedWaveId,
},
attributes: [ 'id' ],
raw: true,
transaction,
});
const remainingCount = Array.isArray(remainingRows) ? remainingRows.length : 0;
await ctx.model.query(
`UPDATE wms_wave_batch
SET total_orders = :remainingCount,
processed_orders = LEAST(processed_orders, :remainingCount),
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id = :waveId`,
{
replacements: {
warehouseId: normalizedWarehouseId,
waveId: normalizedWaveId,
remainingCount,
},
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
// 5. 写订单操作日志 ORDER_WAVE_REMOVE(不影响主流程)
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logPayloads = normalizedRemovableRows.map(row => ({
businessType: 'order',
businessId: `${row.id}`,
operationCode: 'ORDER_WAVE_REMOVE',
operator: {
id: operator && operator.id ? String(operator.id) : null,
name: operator && operator.name ? String(operator.name).trim() : 'system',
},
extras: {
message: `订单从波次 ${String(row && row.wave_no || '').trim() || '未知波次'} 中移除`,
warehouseId: normalizedWarehouseId,
externalLogType: 'API',
},
}));
await operationLogService.createOperationLogs(logPayloads);
}
} catch (logErr) {
ctx.logger.warn(`[recheckOrder.removeUnprintedIntercepted] 写订单操作日志失败,不影响主流程, waveId=${normalizedWaveId}, error=${logErr.message}`);
}
// 6. 触发波次策略快扫,让回池订单重新进入候选池(拦截未解除时策略仍会排除)
try {
if (waveService && typeof waveService.enqueueWaveStrategyQuickScanPostOrderChange === 'function') {
waveService.enqueueWaveStrategyQuickScanPostOrderChange(
normalizedWarehouseId,
removedOrderIds,
{ triggerScan: true, source: 'recheckRemoveUnprintedIntercepted' }
);
}
} catch (scanErr) {
ctx.logger.warn(`[recheckOrder.removeUnprintedIntercepted] 触发策略快扫失败,不影响主流程, waveId=${normalizedWaveId}, error=${scanErr.message}`);
}
ctx.logger.info(
`[recheckOrder.removeUnprintedIntercepted] 波次未打印拦截订单已移除回池, waveId=${normalizedWaveId}, removedCount=${removedOrderIds.length}, orderIds=${removedOrderIds.join(',')}`
);
return { removed_order_ids: removedOrderIds, removed_count: removedOrderIds.length };
}
/**
* 在事务中更新波次拣货任务订单的复核状态,并判断是否需要解绑车任务。
* 复核状态更新后,会先在事务内清理波次内「已拦截且未打印」的订单(回池),
* 避免其卡住任务完成判定。
*
* @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,
}
);
// 复核时在事务内清理波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务完成判定
try {
const cleanupOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const cleanupOrder = await cleanupOrderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
transaction,
});
const cleanupWaveId = Number(cleanupOrder && cleanupOrder.wave_id || 0);
if (cleanupWaveId > 0) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: cleanupWaveId,
warehouseId,
operator,
transaction,
});
}
} catch (removeErr) {
ctx.logger.warn(`[batchQuickRecheck] 清理波次未打印拦截订单失败,不影响复核主流程, orderId=${orderId}, error=${removeErr.message}`);
}
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
FROM wms_wave_pick_task_order
WHERE order_id = :orderId
AND warehouse_id = :warehouseId`,
{
replacements: { orderId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
}
);
const taskId = Number(
(Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0]?.task_id : 0)
);
// 团购模式(pick_mode=1/5)回退:wms_wave_pick_task_order 无记录时,
// 通过订单所属波次查找关联的拣货任务(回退查询使用独立连接,不参与当前事务)
let resolvedTaskId = taskId;
if (resolvedTaskId <= 0) {
resolvedTaskId = await this._resolveTaskIdByWaveFallback(orderId, warehouseId);
}
if (resolvedTaskId <= 0) {
return;
}
// 检查该任务下是否所有订单都已复核完成
const allReviewed = await this._checkTaskOrdersAllReviewed(resolvedTaskId, warehouseId);
if (!allReviewed) {
return;
}
// 任务下所有订单均已复核完成,解绑车任务
try {
await this._unbindCartForTaskInTransaction(resolvedTaskId, warehouseId, operatorUserId, transaction);
ctx.logger.info(
`[batchQuickRecheck] 车任务解绑成功, taskId=${resolvedTaskId}, orderId=${orderId}, operatorUserId=${operatorUserId}`
);
} catch (unbindError) {
ctx.logger.warn(
`[batchQuickRecheck] 解绑车任务失败(复核已成功), taskId=${resolvedTaskId}, orderId=${orderId}, error=${unbindError.message}`
);
}
// 更新 wms_wave_pick_task 任务状态:status=3(已完成),review_status=3(复核通过)
const operatorName = String(operator.name || '').trim();
const taskStatusSetClauses = [
'status = 3',
'review_status = 3',
'review_finish_time = :now',
'review_time = :now',
'update_time = NOW()',
];
if (operatorUserId > 0) {
taskStatusSetClauses.push('review_user_id = :operatorUserId');
taskStatusSetClauses.push('review_user_name = :operatorName');
}
await ctx.model.query(
`UPDATE wms_wave_pick_task
SET ${taskStatusSetClauses.join(',\n ')}
WHERE id = :taskId
AND warehouse_id = :warehouseId`,
{
replacements: { taskId: resolvedTaskId, warehouseId, operatorUserId, operatorName, now },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
/**
* 在事务中解绑车任务:清空波次拣货任务的车绑定、停用拣货车绑定记录、释放拣货车。
*
* @param {number} taskId 波次拣货任务ID。
* @param {number} warehouseId 仓库ID。
* @param {number} operatorUserId 操作员用户ID。
* @param {Object} transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _unbindCartForTaskInTransaction(taskId, warehouseId, operatorUserId, transaction) {
const { ctx } = this;
// 停用拣货车绑定记录
await ctx.model.query(
`UPDATE wms_pick_task_cart_binding
SET is_active = 0,
unbind_user_id = :operatorUserId,
unbind_time = NOW(),
update_time = NOW()
WHERE task_id = :taskId
AND warehouse_id = :warehouseId
AND is_active = 1`,
{
replacements: { taskId, warehouseId, operatorUserId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
}
/**
* 在事务中写入复核操作日志(内部方法)。
*
* @param {Object} params 日志参数。
* @param {number} params.orderId 订单ID。
* @param {number} params.warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
* @param {Date} params.now 操作时间。
* @param {Object} params.transaction Sequelize 事务对象。
* @return {Promise<void>} 无返回值。
*/
async _writeRecheckActionLogInTransaction(params = {}) {
const { orderId, warehouseId, operator, now, transaction } = params;
const operatorId = operator && operator.id ? Number(operator.id) : 0;
const operatorName = operator && operator.name ? String(operator.name).trim() : 'system';
const requestId = `recheck_${warehouseId}_${orderId}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
await this.ctx.model.query(
`INSERT INTO wms_wave_pick_action_log (
task_id,
warehouse_id,
wave_id,
order_id,
sku_id,
location_id,
box_no,
cart_id,
qty_delta,
action_type,
request_id,
operator_id,
device_id,
seq_no,
snapshot
) VALUES (
:taskId,
:warehouseId,
:waveId,
:orderId,
:skuId,
:locationId,
:boxNo,
:cartId,
:qtyDelta,
:actionType,
:requestId,
:operatorId,
:deviceId,
:seqNo,
:snapshot
)`,
{
replacements: {
taskId: 0,
warehouseId: warehouseId || 0,
waveId: null,
orderId: orderId || 0,
skuId: null,
locationId: null,
boxNo: null,
cartId: null,
qtyDelta: 0,
actionType: 'recheck',
requestId,
operatorId,
deviceId: null,
seqNo: 1,
snapshot: JSON.stringify({
order_id: orderId,
operator_name: operatorName,
recheck_time: now instanceof Date ? now.toISOString() : String(now || ''),
}),
},
type: this.ctx.model.QueryTypes.INSERT,
transaction,
}
);
// 双写 order_operation_log(失败不影响主流程)
try {
const ctx = this.ctx;
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId || ''),
operationCode: 'ORDER_RECHECK',
operator: { id: String(operatorId || ''), name: operatorName },
extras: {
warehouseId: warehouseId || 0,
message: '订单复核完成',
orderId: orderId || 0,
},
}], { transaction });
}
} catch (e) {
this.ctx.logger.warn('[recheckOrder._writeRecheckActionLogInTransaction] 写入 order_operation_log 失败', {
error: e && e.message,
orderId,
warehouseId,
});
}
}
}
module.exports = RecheckOrderService;