'use strict'; const MainService = require('../main'); const MAX_BATCH_SIZE = 500; const COMPENSATION_STATUS = 'fin_compensated'; const COMPENSATION_ORDER_TYPE = 'PICK_COMPENSATION'; const CANCELLED_RELEASED_STATUS = 'cancelled_released'; /** * 拣货完成补偿服务。 * * 当 wavePickTaskComplete 因历史 BUG 遗漏扣减库存操作时, * 本服务扫描 wms_picking 中 status='pending' 且订单已迁移到 dispatch 表的记录, * 以与 wavePickTaskComplete 一致的事务逻辑补扣库存并写入出库流水。 */ class PickCompensationService extends MainService { /** * 执行全局拣货补偿扫描与补偿。 * 遍历所有存在 pending 拣货记录的仓库,对符合条件的记录执行补偿。 * * @return {Promise<{totalCompensated: number}>} 全局补偿结果。 */ async executeCompensation() { const { ctx } = this; // Step 1: 查找所有存在 pending 拣货记录的仓库 const warehouseRows = await ctx.model.query(` SELECT DISTINCT warehouse_id FROM wms_picking WHERE status = 'pending' AND warehouse_id > 0 `, { type: ctx.model.QueryTypes.SELECT, }); const warehouses = (Array.isArray(warehouseRows) ? warehouseRows : []) .map(row => Number(row.warehouse_id)) .filter(id => Number.isInteger(id) && id > 0); if (warehouses.length === 0) { return { totalCompensated: 0 }; } let totalCompensated = 0; for (const warehouseId of warehouses) { try { const compensated = await this.compensateWarehouse(warehouseId); totalCompensated += compensated; } catch (error) { ctx.logger.error( `[pick-compensation] 仓库 ${warehouseId} 补偿失败: ${error.message}` ); } } return { totalCompensated }; } /** * 对指定仓库执行单次拣货补偿。 * 先释放已取消订单的库存锁定,再处理拣货完成的 dispatch 订单补偿。 * * @param {number} warehouseId 仓库ID。 * @return {Promise} 本次补偿的拣货记录数。 */ async compensateWarehouse(warehouseId) { const { ctx } = this; const factory = ctx.model && ctx.model.OrderDeliveryFactory; if (!factory || typeof factory.getCurrentModel !== 'function' || typeof factory.getDispatchModel !== 'function') { ctx.logger.warn(`[pick-compensation] 仓库 ${warehouseId} 订单分表工厂不可用,跳过`); return 0; } // 获取所有 pending 订单ID const pendingOrderIds = await this.getPendingOrderIds(warehouseId); if (pendingOrderIds.length === 0) { return 0; } const currentModel = await factory.getCurrentModel(warehouseId); let compensatedCount = 0; // Step A: 释放已取消订单的库存锁定 const cancelledPickingRows = await this.findPendingPickingForCancelledOrders( warehouseId, factory, pendingOrderIds ); if (cancelledPickingRows.length > 0) { ctx.logger.info( `[pick-compensation] 仓库 ${warehouseId} 发现 ${cancelledPickingRows.length} 条已取消订单待释放拣货记录` ); const released = await this.releaseCancelledInTransaction(warehouseId, cancelledPickingRows); compensatedCount += released; } // Step B: 查找符合条件的 dispatch 拣货记录 const pickingRows = await this.findPendingPickingForDispatchOrders( warehouseId, factory, currentModel, pendingOrderIds ); if (pickingRows.length === 0) { return compensatedCount; } ctx.logger.info( `[pick-compensation] 仓库 ${warehouseId} 发现 ${pickingRows.length} 条待补偿拣货记录` ); // Step C: 在事务中执行拣货完成补偿 const dispatchCompensated = await this.compensateInTransaction(warehouseId, pickingRows); compensatedCount += dispatchCompensated; if (dispatchCompensated > 0) { const orderIds = [ ...new Set(pickingRows.map(r => Number(r.order_id))) ]; const pickingIds = pickingRows.map(r => Number(r.id)); const storageIds = [ ...new Set(pickingRows .map(r => Number(r.storage_id)) .filter(id => id > 0)) ]; ctx.logger.info( `[pick-compensation] 仓库 ${warehouseId} 补偿完成:` + `拣货记录 ${pickingIds.join(',')},` + `订单 ${orderIds.join(',')},` + `库存记录 ${storageIds.join(',')}` ); } return compensatedCount; } /** * 获取指定仓库下所有待处理拣货记录的订单ID列表。 * * @param {number} warehouseId 仓库ID。 * @return {Promise>} 待处理的订单ID列表。 */ async getPendingOrderIds(warehouseId) { const { ctx } = this; const pendingOrderRows = await ctx.model.query(` SELECT DISTINCT p.order_id FROM wms_picking p WHERE p.status = 'pending' AND p.warehouse_id = :warehouseId AND p.warehouse_id > 0 `, { replacements: { warehouseId }, type: ctx.model.QueryTypes.SELECT, }); return (Array.isArray(pendingOrderRows) ? pendingOrderRows : []) .map(row => Number(row.order_id)) .filter(id => Number.isInteger(id) && id > 0); } /** * 查找仓库下待补偿的拣货记录(dispatch 拣货完成场景)。 * 条件:status='pending',对应订单在 dispatch 表中 pick_status='fin', * 且订单不在 current 表中(已迁移到配送表)。 * * @param {number} warehouseId 仓库ID。 * @param {Object} factory OrderDeliveryFactory 实例。 * @param {Object} currentModel 订单 current 表的 Sequelize 模型。 * @param {Array} pendingOrderIds 待处理的订单ID列表。 * @return {Promise>} 待补偿的拣货记录列表。 */ async findPendingPickingForDispatchOrders(warehouseId, factory, currentModel, pendingOrderIds) { const { ctx, app } = this; if (!Array.isArray(pendingOrderIds) || pendingOrderIds.length === 0) { return []; } // 查询 current 表:哪些订单还在主表中 const currentOrders = await currentModel.findAll({ where: { id: { [app.Sequelize.Op.in]: pendingOrderIds }, warehouse_id: warehouseId, }, attributes: [ 'id' ], raw: true, }); const currentOrderIdSet = new Set( (Array.isArray(currentOrders) ? currentOrders : []) .map(row => Number(row.id)) ); // 查询 dispatch 表:哪些订单 pick_status='fin' const dispatchModel = await factory.getDispatchModel(warehouseId); const dispatchOrders = await dispatchModel.findAll({ where: { id: { [app.Sequelize.Op.in]: pendingOrderIds }, warehouse_id: warehouseId, pick_status: 'fin', }, attributes: [ 'id' ], raw: true, }); const dispatchOrderIdSet = new Set( (Array.isArray(dispatchOrders) ? dispatchOrders : []) .map(row => Number(row.id)) ); // 符合条件的订单:在 dispatch 中 pick_status='fin',且不在 current 中 const eligibleOrderIds = pendingOrderIds.filter( id => dispatchOrderIdSet.has(id) && !currentOrderIdSet.has(id) ); if (eligibleOrderIds.length === 0) { return []; } // 查询对应的拣货记录(带 storage_id,限制每批处理上限) const pickingRows = await ctx.model.query(` SELECT p.id, p.order_id, p.warehouse_id, p.storage_id, p.quantity FROM wms_picking p WHERE p.status = 'pending' AND p.warehouse_id = :warehouseId AND p.order_id IN (:orderIds) AND p.storage_id IS NOT NULL AND p.storage_id > 0 AND p.deleted_at IS NULL -- 排除软删除记录 ORDER BY p.id ASC LIMIT :limit `, { replacements: { warehouseId, orderIds: eligibleOrderIds, limit: MAX_BATCH_SIZE, }, type: ctx.model.QueryTypes.SELECT, }); return Array.isArray(pickingRows) ? pickingRows : []; } /** * 查找已取消订单关联的待处理拣货记录。 * 在 pendingOrderIds 中筛选 dispatch 表中 status='cancel' 的订单, * 返回对应的 wms_picking 记录(status='pending')。 * * @param {number} warehouseId 仓库ID。 * @param {Object} factory OrderDeliveryFactory 实例。 * @param {Array} pendingOrderIds 待处理的订单ID列表。 * @return {Promise>} 已取消订单对应的拣货记录列表。 */ async findPendingPickingForCancelledOrders(warehouseId, factory, pendingOrderIds) { const { ctx, app } = this; if (!Array.isArray(pendingOrderIds) || pendingOrderIds.length === 0) { return []; } // 查询 dispatch 表中已取消的订单 const dispatchModel = await factory.getDispatchModel(warehouseId); const cancelledOrders = await dispatchModel.findAll({ where: { id: { [app.Sequelize.Op.in]: pendingOrderIds }, warehouse_id: warehouseId, status: 'cancel', }, attributes: [ 'id' ], raw: true, }); const cancelledOrderIds = (Array.isArray(cancelledOrders) ? cancelledOrders : []) .map(row => Number(row.id)); if (cancelledOrderIds.length === 0) { return []; } // 查询对应的拣货记录(带 storage_id,限制每批处理上限) const pickingRows = await ctx.model.query(` SELECT p.id, p.order_id, p.warehouse_id, p.storage_id, p.quantity FROM wms_picking p WHERE p.status = 'pending' AND p.warehouse_id = :warehouseId AND p.order_id IN (:orderIds) AND p.storage_id IS NOT NULL AND p.storage_id > 0 AND p.deleted_at IS NULL -- 排除软删除记录 ORDER BY p.id ASC LIMIT :limit `, { replacements: { warehouseId, orderIds: cancelledOrderIds, limit: MAX_BATCH_SIZE, }, type: ctx.model.QueryTypes.SELECT, }); return Array.isArray(pickingRows) ? pickingRows : []; } /** * 在事务中释放已取消订单的库存锁定。 * * 事务步骤: * 1. 重新查询 wms_picking(status='pending')汇总各 storage_id 的 SUM(quantity) * 2. SELECT wms_storage FOR UPDATE * 3. 校验 locked_quantity >= 解锁数量 * 4. UPDATE wms_storage 只解锁 locked_quantity(不扣减 quantity) * 5. UPDATE wms_picking SET status='cancelled_released' * * @param {number} warehouseId 仓库ID。 * @param {Array} cancelledPickingRows 已取消订单关联的拣货记录列表。 * @return {Promise} 释放成功的拣货记录数。 */ async releaseCancelledInTransaction(warehouseId, cancelledPickingRows) { const { ctx, app } = this; if (!Array.isArray(cancelledPickingRows) || cancelledPickingRows.length === 0) { return 0; } const pickingIds = cancelledPickingRows.map(row => Number(row.id)); const transaction = await ctx.model.transaction(); try { // Step 1: 重新查询 wms_picking,确保只处理仍然 status='pending' 的记录 const confirmedRows = await ctx.model.query(` SELECT p.id, p.order_id, p.storage_id, p.quantity FROM wms_picking p WHERE p.id IN (:pickingIds) AND p.warehouse_id = :warehouseId AND p.status = 'pending' AND p.storage_id IS NOT NULL AND p.storage_id > 0 AND p.deleted_at IS NULL -- 排除软删除记录 `, { replacements: { pickingIds, warehouseId }, type: ctx.model.QueryTypes.SELECT, transaction, }); const normalizedConfirmedRows = Array.isArray(confirmedRows) ? confirmedRows : []; if (normalizedConfirmedRows.length === 0) { await transaction.rollback(); return 0; } // 汇总各 storage_id 的 SUM(quantity) const storageQtyMap = new Map(); for (const row of normalizedConfirmedRows) { const sid = Number(row.storage_id); const qty = Number(row.quantity) || 0; storageQtyMap.set(sid, (storageQtyMap.get(sid) || 0) + qty); } const storageIds = [ ...storageQtyMap.keys() ]; // Step 2: SELECT wms_storage FOR UPDATE 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' ], lock: transaction.LOCK.UPDATE, raw: true, transaction, }); // Step 3: 校验 locked_quantity >= 解锁数量 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 this.createBusinessError( `库存记录 ${sid} 锁定数量不足:当前锁定 ${locked},需解锁 ${deduction}`, 400 ); } } // Step 4: UPDATE wms_storage 只解锁 locked_quantity(不扣减 quantity) const summaryRows = []; for (const [ sid, totalQty ] of storageQtyMap) { summaryRows.push({ storage_id: sid, total_qty: totalQty }); } const caseClauses = summaryRows .map(r => `WHEN ${Number(r.storage_id)} THEN ${Number(r.total_qty)}`) .join(' '); const explicitStorageIdList = storageIds.map(id => Number(id)).join(', '); await ctx.model.query(` UPDATE wms_storage SET locked_quantity = locked_quantity - CASE id ${caseClauses} END, updated_at = NOW() WHERE id IN (${explicitStorageIdList}) AND warehouse_id = :warehouseId `, { replacements: { warehouseId }, transaction, }); // Step 5: UPDATE wms_picking SET status='cancelled_released' const compensatedPickingIds = normalizedConfirmedRows.map(r => Number(r.id)); await ctx.model.query(` UPDATE wms_picking SET status = :status, updated_at = NOW() WHERE id IN (:pickingIds) AND warehouse_id = :warehouseId `, { replacements: { status: CANCELLED_RELEASED_STATUS, pickingIds: compensatedPickingIds, warehouseId, }, transaction, }); await transaction.commit(); return compensatedPickingIds.length; } catch (error) { await transaction.rollback(); throw error; } } /** * 在事务中执行拣货补偿,与 wavePickTaskComplete 保持一致的逻辑。 * * 事务步骤: * 1. 重新查询 wms_picking(status='pending')汇总各 storage_id 的 SUM(quantity) * 2. SELECT wms_storage FOR UPDATE * 3. 校验 locked_quantity >= 扣减数量 * 4. UPDATE wms_storage 扣减 locked_quantity 和 quantity(CASE WHEN) * 5. 查询 dispatch 表获取订单的 delivery_order_code 和 source_order_codes, * 为每个拣货记录 INSERT 一条 wms_storage_transaction(OUTBOUND, PICK_COMPENSATION), * 同一 storage 的多条记录共享相同的 before/after 数量 * 6. UPDATE wms_picking SET status='fin_compensated' * * @param {number} warehouseId 仓库ID。 * @param {Array} pickingRows 待补偿的拣货记录列表。 * @return {Promise} 补偿成功的拣货记录数。 */ async compensateInTransaction(warehouseId, pickingRows) { const { ctx, app } = this; if (!Array.isArray(pickingRows) || pickingRows.length === 0) { return 0; } const pickingIds = pickingRows.map(row => Number(row.id)); const transaction = await ctx.model.transaction(); try { // Step 1: 重新查询 wms_picking,确保只处理仍然 status='pending' 的记录 const confirmedRows = await ctx.model.query(` SELECT p.id, p.order_id, p.storage_id, p.quantity FROM wms_picking p WHERE p.id IN (:pickingIds) AND p.warehouse_id = :warehouseId AND p.status = 'pending' AND p.storage_id IS NOT NULL AND p.storage_id > 0 AND p.deleted_at IS NULL -- 排除软删除记录 `, { replacements: { pickingIds, warehouseId }, type: ctx.model.QueryTypes.SELECT, transaction, }); const normalizedConfirmedRows = Array.isArray(confirmedRows) ? confirmedRows : []; if (normalizedConfirmedRows.length === 0) { await transaction.rollback(); return 0; } // 汇总各 storage_id 的 SUM(quantity) const storageQtyMap = new Map(); for (const row of normalizedConfirmedRows) { const sid = Number(row.storage_id); const qty = Number(row.quantity) || 0; storageQtyMap.set(sid, (storageQtyMap.get(sid) || 0) + qty); } const storageIds = [ ...storageQtyMap.keys() ]; // Step 2: SELECT wms_storage FOR UPDATE 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, }); // Step 3: 校验 locked_quantity >= 扣减数量 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 this.createBusinessError( `库存记录 ${sid} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`, 400 ); } } // Step 4: UPDATE wms_storage 扣减 locked_quantity 和 quantity(CASE WHEN) const summaryRows = []; for (const [ sid, totalQty ] of storageQtyMap) { summaryRows.push({ storage_id: sid, total_qty: totalQty }); } const caseClauses = summaryRows .map(r => `WHEN ${Number(r.storage_id)} THEN ${Number(r.total_qty)}`) .join(' '); const explicitStorageIdList = storageIds.map(id => Number(id)).join(', '); const [ updateResult ] = 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 (${explicitStorageIdList}) AND warehouse_id = :warehouseId `, { replacements: { warehouseId }, transaction, }); if (!updateResult || Number(updateResult) === 0) { ctx.logger.warn( `[pick-compensation] wms_storage UPDATE 影响 0 行,storageIds=[${explicitStorageIdList}], warehouseId=${warehouseId}` ); } else { ctx.logger.info( `[pick-compensation] wms_storage UPDATE 影响 ${updateResult} 行,storageIds=[${explicitStorageIdList}], warehouseId=${warehouseId}` ); } // Step 5: INSERT wms_storage_transaction(每个拣货记录对应一条流水) const confirmedOrderIds = [ ...new Set(normalizedConfirmedRows.map(r => Number(r.order_id))) ]; // 构建 storage_id -> storage row 映射 const storageRowMap = new Map(); for (const sRow of storageRows) { storageRowMap.set(Number(sRow.id), sRow); } // 构建 storage 变更前后的数量映射(同一 storage 多条拣货记录共享相同的 before/after) const beforeQtyMap = new Map(); const beforeLockedMap = new Map(); for (const sRow of storageRows) { const sid = Number(sRow.id); beforeQtyMap.set(sid, Number(sRow.quantity) || 0); beforeLockedMap.set(sid, Number(sRow.locked_quantity) || 0); } // 查询 dispatch 表获取 delivery_order_code 和 source_order_codes const factory = ctx.model && ctx.model.OrderDeliveryFactory; const dispatchModel = factory && typeof factory.getDispatchModel === 'function' ? await factory.getDispatchModel(warehouseId) : null; const orderInfoMap = new Map(); if (dispatchModel && confirmedOrderIds.length > 0) { const dispatchRows = await dispatchModel.findAll({ where: { id: { [app.Sequelize.Op.in]: confirmedOrderIds }, warehouse_id: warehouseId, }, attributes: [ 'id', 'delivery_order_code', 'source_order_codes' ], raw: true, transaction, }); for (const dRow of dispatchRows) { orderInfoMap.set(Number(dRow.id), { delivery_order_code: dRow.delivery_order_code, source_order_codes: dRow.source_order_codes, }); } } const transactionRows = []; for (const pickRow of normalizedConfirmedRows) { const orderId = Number(pickRow.order_id); const orderInfo = orderInfoMap.get(orderId); const sid = Number(pickRow.storage_id); const deduction = Number(pickRow.quantity) || 0; const sRow = storageRowMap.get(sid); if (!sRow || deduction <= 0) continue; 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: beforeQtyMap.get(sid), after_quantity: Math.max(0, beforeQtyMap.get(sid) - (storageQtyMap.get(sid) || 0)), before_locked_quantity: beforeLockedMap.get(sid), after_locked_quantity: Math.max(0, beforeLockedMap.get(sid) - (storageQtyMap.get(sid) || 0)), batch_no: sRow.batch_no || null, inventory_type: sRow.inventory_type || 'ZP', order_type: COMPENSATION_ORDER_TYPE, order_no: orderInfo?.delivery_order_code || String(orderId), order_id: orderId, source_order_codes: orderInfo?.source_order_codes || String(orderId), operator_id: 'system', operator_name: 'system', remark: '拣货完成补偿出库', created_at: new Date(), }); } if (transactionRows.length > 0) { await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction }); } // Step 6: UPDATE wms_picking SET status='fin_compensated' const compensatedPickingIds = normalizedConfirmedRows.map(r => Number(r.id)); await ctx.model.query(` UPDATE wms_picking SET status = :compensationStatus, updated_at = NOW() WHERE id IN (:pickingIds) AND warehouse_id = :warehouseId `, { replacements: { compensationStatus: COMPENSATION_STATUS, pickingIds: compensatedPickingIds, warehouseId, }, transaction, }); await transaction.commit(); return compensatedPickingIds.length; } catch (error) { await transaction.rollback(); throw error; } } /** * 生成带业务状态码的错误对象。 * * @param {string} message 错误文案。 * @param {number} [code=400] 错误码。 * @return {Error} 错误对象。 */ createBusinessError(message, code = 400) { const error = new Error(message); error.code = code; return error; } } module.exports = PickCompensationService;