'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} 扫描结果,包含 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} waveIds 波次ID或波次ID数组。 * @param {number} warehouseId 仓库ID。 * @return {Promise} 无返回值。 */ 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} 扫描视图,包含 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} 扁平化扫描视图,包含 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} 波次视图对象,包含 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>} 波次视图列表,每项包含 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(), 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(), 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} 拣货模式编码,未找到返回 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} 拣货任务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>} 订单基本信息列表,每项含 order_id、delivery_order_code、 * waybill_no、pick_status、is_printed、is_reviewed、shop_nick、items_count、 * wave_index、recheck_status、wave_id、wave_no、order_type、status、 * logistics_name、store_remark、intercept_status、items_weight、items_hash、items_crc、stock 等字段。 */ async getWaveOrdersBasic(waveNo, warehouseId) { const normalizedWaveNo = String(waveNo || '').trim(); if (!normalizedWaveNo) { return []; } const orderModel = await this.getOrderModelByTableType('current', warehouseId); const orderRows = await orderModel.findAll({ where: { wave_no: normalizedWaveNo, warehouse_id: warehouseId, recheck_status: { [this.app.Sequelize.Op.ne]: 'fin' }, }, attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'pick_status', 'wave_id', 'wave_no', 'order_type', 'status', 'recheck_status', 'items_count', 'shop_nick', 'logistics_name', 'print_status', 'store_id', 'intercept_status', 'items_weight', 'items_hash', 'items_crc', ], order: [[ 'id', 'ASC' ]], raw: true, }); const { ctx } = this; const orderRowsArray = Array.isArray(orderRows) ? orderRows : []; const orderIds = orderRowsArray.map(row => Number(row.id || 0)); // 批量查询货主备注(wms_store_warehouse.store_remask) const storeRemarkMap = new Map(); if (orderIds.length > 0 && ctx.model && ctx.model.StoreWarehouse) { const storeIds = [ ...new Set( orderRowsArray .map(row => Number(row.store_id || 0)) .filter(id => id > 0) ), ]; if (storeIds.length > 0) { const swRows = await ctx.model.StoreWarehouse.findAll({ where: { store_id: { [this.app.Sequelize.Op.in]: storeIds }, warehouse_id: warehouseId, }, attributes: [ 'store_id', 'store_remask' ], raw: true, }); for (const sw of (Array.isArray(swRows) ? swRows : [])) { const sid = Number(sw.store_id || 0); if (sid > 0 && !storeRemarkMap.has(sid)) { storeRemarkMap.set(sid, String(sw.store_remask || '').trim()); } } } } // 批量查询运单信息 const waybillMap = new Map(); if (orderIds.length > 0 && ctx.model && ctx.model.OrderExpress) { const expressRows = await ctx.model.OrderExpress.findAll({ where: { order_id: orderIds, warehouse_id: warehouseId }, attributes: [ 'order_id', 'waybill_code' ], order: [[ 'id', 'ASC' ]], raw: true, }); for (const er of (Array.isArray(expressRows) ? expressRows : [])) { const oid = Number(er.order_id || 0); if (oid > 0 && !waybillMap.has(oid)) { waybillMap.set(oid, String(er.waybill_code || '').trim()); } } } // 批量查询波次顺序索引(wms_order_wave_index) const waveIndexMap = new Map(); if (orderIds.length > 0 && ctx.model && typeof ctx.model.query === 'function') { const waveIds = [ ...new Set( orderRowsArray .map(row => Number(row.wave_id || 0)) .filter(id => id > 0) ), ]; if (waveIds.length > 0) { try { const waveIndexRows = await ctx.model.query( ` SELECT order_id, wave_index FROM wms_order_wave_index WHERE warehouse_id = :warehouseId AND wave_id IN (:waveIds) AND order_id IN (:orderIds) `, { replacements: { warehouseId, waveIds, orderIds }, type: ctx.model.QueryTypes && ctx.model.QueryTypes.SELECT, } ); for (const wr of (Array.isArray(waveIndexRows) ? waveIndexRows : [])) { const wrOrderId = Number(wr && wr.order_id || 0); if (wrOrderId > 0) { waveIndexMap.set(wrOrderId, Number(wr.wave_index || 0)); } } } catch (e) { ctx.logger.warn(`[recheckOrder.getWaveOrdersBasic] 查询波次索引失败, waveNo=${normalizedWaveNo}, error=${e.message}`); } } } // 构建订单列表 const orderList = orderRowsArray.map((row, index) => { const orderId = Number(row.id || 0); const recheckStatus = String(row.recheck_status || '').trim(); const printStatus = String(row.print_status || '').trim(); // 运单号:从 wms_order_express 关联表查询 const waybillNo = waybillMap.has(orderId) ? (waybillMap.get(orderId) || '') : ''; return { order_id: orderId, delivery_order_code: String(row.delivery_order_code || row.pre_delivery_order_code || '').trim(), waybill_no: waybillNo, pick_status: String(row.pick_status || '').trim(), is_printed: printStatus === 'fin', is_reviewed: recheckStatus === 'fin', shop_nick: String(row.shop_nick || '').trim(), items_count: Number(row.items_count || 0), wave_index: waveIndexMap.has(orderId) ? waveIndexMap.get(orderId) : index, recheck_status: recheckStatus, wave_id: Number(row.wave_id || 0), wave_no: String(row.wave_no || '').trim(), order_type: String(row.order_type || '').trim(), status: Number(row.status || 0), logistics_name: String(row.logistics_name || '').trim(), store_id: Number(row.store_id || 0), store_remark: storeRemarkMap.has(Number(row.store_id || 0)) ? storeRemarkMap.get(Number(row.store_id || 0)) : '', intercept_status: String(row.intercept_status || '').trim(), items_weight: Number(row.items_weight || 0), items_hash: String(row.items_hash || '').trim(), items_crc: Number(row.items_crc || 0), }; }); // 排序:未复核的排前面,其次按波次内序号从小到大 orderList.sort((a, b) => { const aReviewed = a.is_reviewed ? 1 : 0; const bReviewed = b.is_reviewed ? 1 : 0; if (aReviewed !== bReviewed) { return aReviewed - bReviewed; } return a.wave_index - b.wave_index; }); // 补充库存信息 const enrichedList = await this.enrichOrdersWithStock(orderList, warehouseId); return enrichedList; } /** * 批量查询包材推荐信息。 * 根据订单的 items_hash + items_crc 组合,从 wms_package_material_item_relation 表 * 查询最匹配的包材推荐(按 bind_count 降序取 top-1)。 * @param {Object[]} orderList 订单列表,每项需含 items_hash、items_crc 字段。 * @param {number} warehouseId 仓库ID。 * @return {Promise>} 以 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} 补充了 stock 字段的订单列表。 */ async enrichOrdersWithStock(orderList, warehouseId) { if (!Array.isArray(orderList) || orderList.length === 0) { return orderList; } const orderIds = orderList.map(o => Number(o.order_id || 0)).filter(Boolean); if (orderIds.length === 0) { return orderList; } // 1. 批量查询所有订单的商品明细 const orderItemsModel = await this.getOrderItemsModelByTableType('current', warehouseId); const allOrderItems = await orderItemsModel.findAll({ where: { order_id: { [this.app.Sequelize.Op.in]: orderIds }, }, attributes: [ 'order_id', 'stock_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot', 'owner_code' ], order: [[ 'id', 'ASC' ]], raw: true, }); const itemsArray = Array.isArray(allOrderItems) ? allOrderItems : []; // 2. 收集所有唯一的 stock_id const stockIds = [ ...new Set( itemsArray .map(item => Number(item.stock_id)) .filter(Boolean) ) ]; // 3. 批量查询库存信息(复用 getStockDetails,含条码与图片) const stockMap = new Map(); const barcodeMap = new Map(); const imagesByStockId = new Map(); if (stockIds.length > 0) { const stockDetails = await this.ctx.service.systems.stockWarehouse.getStockDetails( stockIds, { warehouseId } ); for (const detail of stockDetails) { const sid = Number(detail.id); stockMap.set(sid, detail); // 从 getStockDetails 提取条码 if (Array.isArray(detail.barcodes) && detail.barcodes.length > 0) { barcodeMap.set(sid, detail.barcodes.map(bc => String(bc.barcode || '').trim()).filter(Boolean)); } // 从 getStockDetails 提取图片 URL(兼容数组/字符串格式) const imageUrls = Array.isArray(detail.image_url) ? detail.image_url.map(u => String(u || '').trim()).filter(Boolean) : (detail.image_url ? [ String(detail.image_url).trim() ] : []); if (imageUrls.length > 0) { imagesByStockId.set(sid, imageUrls); } } } // 4. 批量查询货主备注名(wms_store_warehouse.store_remask),按 store_id 映射 const storeRemarkMapByStock = new Map(); if (stockMap.size > 0 && this.ctx.model && this.ctx.model.StoreWarehouse) { const storeIdsForRemark = [ ...new Set( [ ...stockMap.values() ] .map(detail => Number(detail.store_id || 0)) .filter(id => id > 0) ) ]; if (storeIdsForRemark.length > 0) { const swRows = await this.ctx.model.StoreWarehouse.findAll({ where: { store_id: { [this.app.Sequelize.Op.in]: storeIdsForRemark }, warehouse_id: warehouseId, }, attributes: [ 'store_id', 'store_remask' ], raw: true, }); for (const sw of (Array.isArray(swRows) ? swRows : [])) { const sid = Number(sw.store_id || 0); if (sid > 0 && !storeRemarkMapByStock.has(sid)) { storeRemarkMapByStock.set(sid, String(sw.store_remask || '').trim()); } } } } // 5. 检测共享条码:以订单货主(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(), barcodes, images, has_shared_barcode: hasSharedBarcode, need_recheck: String(stockInfo.need_recheck || 'Y').trim(), 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} 扫描结果。 */ 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} 复核确认结果。 */ 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 updateValues = { recheck_status: 'fin', recheck_time: now, updated_at: now, }; const updateResult = await orderModel.update(updateValues, { where: orderWhere, }); const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0); if (affectedRows <= 0) { throw new Error('未找到对应订单'); } const operator = this.getOrderLogOperator(); const reviewNo = this.buildRecheckReviewNo(orderId, now); const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(); const operatorNo = String(operator.id || '').trim(); const operatorName = String(operator.name || '').trim(); await ctx.model.query( ` INSERT INTO wms_recheck_task ( review_no, warehouse_id, order_id, order_no, waybill_no, task_status, scan_status, review_emp_no, review_emp_name, scan_emp_no, scan_emp_name, scan_time, finish_time, remark ) VALUES ( :reviewNo, :warehouseId, :orderId, :orderNo, :waybillNo, :taskStatus, :scanStatus, :reviewEmpNo, :reviewEmpName, :scanEmpNo, :scanEmpName, :scanTime, :finishTime, :remark ) `, { replacements: { reviewNo, warehouseId, orderId, orderNo, waybillNo, taskStatus: 2, scanStatus: 1, reviewEmpNo: operatorNo, reviewEmpName: operatorName, scanEmpNo: operatorNo, scanEmpName: operatorName, scanTime: now, finishTime: now, remark: '系统复核完成', }, type: ctx.model.QueryTypes.INSERT, } ); // 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务 await this.updateTaskOrderReviewAndTryUnbindCart(orderId, warehouseId, operator, now); // 写入操作日志 await this._writeRecheckActionLog({ orderId, waybillNo, warehouseId, operator, now, }); // 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成, // 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失 await this._tryCompleteWaveIfAllOrdersRechecked(orderId, order.wave_id, warehouseId, operator, now); return { order_id: orderId, waybill_no: waybillNo, recheck_status: 'fin', recheck_time: now, review_no: reviewNo, }; } /** * 团购波次批量复核:将波次下所有非拦截订单标记为已复核,并更新波次批次状态为复核完成。 * @param {number} waveId 波次ID。 * @param {number} warehouseId 仓库ID。 * @return {Promise} 批量复核结果,包含 wave_id、success_count、 * intercepted_count、total_count。 */ async confirmRecheckByWaveId(waveId, warehouseId) { const { ctx } = this; const normalizedWaveId = Number(waveId); if (!Number.isFinite(normalizedWaveId) || normalizedWaveId <= 0) { throw new Error('波次ID无效'); } // 查询波次信息,判断是否为团购波次 const waveRows = await ctx.model.query( `SELECT wave_id, wave_no, wave_type FROM wms_wave_batch WHERE wave_id = :waveId AND warehouse_id = :warehouseId LIMIT 1`, { replacements: { waveId: normalizedWaveId, warehouseId }, type: ctx.model.QueryTypes.SELECT, } ); const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null; if (!waveRow) { throw new Error('未找到对应波次'); } const waveType = Number(waveRow.wave_type || 0); const pickMode = await this.getPickModeByWaveId(normalizedWaveId, warehouseId); const isGroupBuy = waveType === 1 || pickMode === 1; if (!isGroupBuy) { throw new Error('该波次不是团购波次,不允许批量复核'); } // 查询波次下所有订单 const orderModel = await this.getOrderModelByTableType('current', warehouseId); const orderRows = await orderModel.findAll({ where: { wave_id: normalizedWaveId, warehouse_id: warehouseId, }, attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'intercept_status', 'pick_status', 'recheck_status', ], raw: true, }); const orderList = Array.isArray(orderRows) ? orderRows : []; if (orderList.length === 0) { throw new Error('波次下没有订单'); } // 分离拦截订单与非拦截订单 const normalOrders = []; const interceptedOrders = []; for (const order of orderList) { if (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); } 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, }); 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} 无返回值。 */ 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} 无返回值。 */ 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} 任务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} 全部已复核返回 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} 无返回值。 */ 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} 无返回值。 */ 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} 订单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} 订单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, matched_order_ids:Array}>} 命中上下文。 */ 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, matched_order_ids:Array}>} 命中上下文。 */ 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} 任务行,未找到返回 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>} 字段名集合。 */ 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} 语义化视图。 */ 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} 语义化视图。 */ 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} 平铺后的订单列表。 */ 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} taskOrders 任务订单行。 * @return {Promise>} 扩展后的任务订单行。 */ 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} taskOrders 任务订单行。 * @return {Array} 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} taskOrders 任务订单行。 * @return {Array} 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} taskOrders 任务订单行。 * @return {Array} 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} taskOrders 任务订单行。 * @param {Function} keyGetter 分组键生成器。 * @param {Function} initGroup 分组初始化函数。 * @return {Array} 分组列表。 */ 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} 列表结果,包含 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} { list: Array, 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.weight_type, o.status, o.create_at, o.recheck_time, 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, 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, })); 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} { list: Array, 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} 批量拦截结果,包含 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} 拦截扫描结果,包含 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} 批量复核结果,包含 success、failed、success_count、failed_count。 */ async batchQuickRecheck(data = {}) { const { ctx } = this; const warehouseId = this.getWarehouseId(); const orderIds = this.normalizeOrderIds(data); if (orderIds.length === 0) { this.ctx.throw(400, '订单ID列表不能为空'); } // ── 1. 批量查询所有订单的当前状态 ── const orderModel = await this.getOrderModel('order', warehouseId); const orderRows = await orderModel.findAll({ where: this.buildOrderWhere(orderIds, warehouseId), attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status', 'pick_status', 'recheck_status', 'wave_id', 'wave_no', ], raw: true, }); const orderMap = new Map(); for (const row of orderRows) { orderMap.set(Number(row.id), row); } // ── 2. 前置条件检查:将订单分为有效订单与跳过订单 ── const validOrders = []; const failedOrders = []; for (const orderId of orderIds) { const order = orderMap.get(orderId); if (!order) { failedOrders.push({ order_id: orderId, reason: '未找到对应订单' }); continue; } 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}`, }); } } 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} 处理结果,包含 success/failed 列表及计数。 */ async batchQuickRecheckByWave(data = {}) { const { ctx } = this; const warehouseId = this.getWarehouseId(); const waveIds = this.normalizeWaveIds(data); if (waveIds.length === 0) { this.ctx.throw(400, '波次ID列表不能为空'); } // ── 1. 批量查询所有波次下的订单 ── const orderModel = await this.getOrderModel('order', warehouseId); const orderRows = await orderModel.findAll({ where: { wave_id: { [this.app.Sequelize.Op.in]: waveIds }, warehouse_id: warehouseId, }, attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status', 'pick_status', 'recheck_status', 'wave_id', 'wave_no', ], raw: true, }); // 按 wave_id 分组 const waveOrderMap = new Map(); for (const row of orderRows) { const wid = Number(row.wave_id); if (!waveOrderMap.has(wid)) { waveOrderMap.set(wid, []); } waveOrderMap.get(wid).push(row); } // ── 2. 前置条件检查:逐波次、逐订单校验 ── const allSuccessOrders = []; const allFailedOrders = []; for (const waveId of waveIds) { const waveOrders = waveOrderMap.get(waveId) || []; if (waveOrders.length === 0) { allFailedOrders.push({ wave_id: waveId, reason: '波次下无订单', }); continue; } const validOrders = []; for (const order of waveOrders) { const orderId = Number(order.id); 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}`, }); } } } 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} 无返回值。 */ 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} 无返回值。 */ async _markRecheckForOrder(order, warehouseId, transaction) { const { ctx } = this; const orderId = Number(order.id); // 校验订单是否允许复核(拣货已完成且未被拦截) this.assertOrderCanRecheck(order); const now = new Date(); // 更新订单复核状态 const orderModel = await this.getOrderModel('order', warehouseId); await orderModel.update( { recheck_status: 'fin', print_status: 'fin', recheck_time: now, updated_at: now, }, { where: this.buildOrderWhere([ orderId ], warehouseId), transaction, validate: false, hooks: false, } ); // 插入 wms_recheck_task 复核记录 const operator = this.getOrderLogOperator(); const reviewNo = this.buildRecheckReviewNo(orderId, now); const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim(); const operatorNo = String(operator.id || '').trim(); const operatorName = String(operator.name || '').trim(); await ctx.model.query( `INSERT INTO wms_recheck_task ( review_no, warehouse_id, order_id, order_no, waybill_no, task_status, scan_status, review_emp_no, review_emp_name, scan_emp_no, scan_emp_name, scan_time, finish_time, remark ) VALUES ( :reviewNo, :warehouseId, :orderId, :orderNo, :waybillNo, :taskStatus, :scanStatus, :reviewEmpNo, :reviewEmpName, :scanEmpNo, :scanEmpName, :scanTime, :finishTime, :remark )`, { replacements: { reviewNo, warehouseId, orderId, orderNo, waybillNo: '', taskStatus: 2, scanStatus: 1, reviewEmpNo: operatorNo, reviewEmpName: operatorName, scanEmpNo: operatorNo, scanEmpName: operatorName, scanTime: now, finishTime: now, remark: '系统复核完成(批量快捷复核)', }, type: ctx.model.QueryTypes.INSERT, transaction, } ); // 更新波次拣货任务订单复核状态,并判断是否需要解绑车任务 await this._updateTaskOrderReviewInTransaction(orderId, warehouseId, operator, now, transaction); // 写入操作日志 await this._writeRecheckActionLogInTransaction({ orderId, warehouseId, operator, now, transaction, }); // 散单复核完成后,在事务内检查订单所属波次下所有订单是否均已复核完成, // 若全部完成则更新波次状态为复核完成(wave_status=5),使波次从 batchList 中消失 await this._tryCompleteWaveInTransaction(orderId, order.wave_id, warehouseId, operator, now, transaction); } /** * 散单复核完成后,检查订单所属波次下所有订单是否均已复核完成, * 若全部完成则更新 wms_wave_batch.wave_status = 5(复核完成), * 使该波次从 batchList 中自然消失。 * * @param {number} orderId 当前复核的订单ID。 * @param {number|string|null} waveId 订单所属波次ID。 * @param {number} warehouseId 仓库ID。 * @param {{ id: string|null, name: string }} operator 操作人信息。 * @param {Date} now 当前时间。 * @return {Promise} 无返回值。 */ 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} 无返回值。 */ 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} 无返回值。 */ 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} 无返回值。 */ 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} 无返回值。 */ 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;