- scripts/auth/grant-cs-up.js: 客服组及以上角色批量授权(dev+prod) - scripts/auth/revoke-cs-up.js: 客服组及以上角色批量取消授权(dev+prod) - .github/agents/开发.agent.md: 新增关键定位地图第5项-客服组权限授权脚本 - .cursor/agents/wms-dev-agent.md: 同步 dev-agent 配置
744 lines
25 KiB
JavaScript
744 lines
25 KiB
JavaScript
'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<number>} 本次补偿的拣货记录数。
|
||
*/
|
||
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<Array<number>>} 待处理的订单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<number>} pendingOrderIds 待处理的订单ID列表。
|
||
* @return {Promise<Array<Object>>} 待补偿的拣货记录列表。
|
||
*/
|
||
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<number>} pendingOrderIds 待处理的订单ID列表。
|
||
* @return {Promise<Array<Object>>} 已取消订单对应的拣货记录列表。
|
||
*/
|
||
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<Object>} cancelledPickingRows 已取消订单关联的拣货记录列表。
|
||
* @return {Promise<number>} 释放成功的拣货记录数。
|
||
*/
|
||
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' 的记录
|
||
// 使用 FOR UPDATE 行锁,防止并发事务读取到相同的 picking 记录导致重复释放锁定库存
|
||
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 -- 排除软删除记录
|
||
FOR UPDATE
|
||
`, {
|
||
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)
|
||
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 4.5: 写入 wms_storage_transaction 解锁流水
|
||
const unlockTransactionRows = [];
|
||
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;
|
||
unlockTransactionRows.push({
|
||
transaction_type: 'UNLOCK',
|
||
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: beforeQty,
|
||
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: 'PICKING_CANCEL_UNLOCK',
|
||
order_no: normalizedConfirmedRows
|
||
.filter(r => Number(r.storage_id) === sid)
|
||
.map(r => String(r.order_id))
|
||
.join(',')
|
||
.slice(0, 255),
|
||
order_id: 0,
|
||
operator_id: '',
|
||
operator_name: 'pick_compensation',
|
||
remark: '拣货补偿-释放已取消订单库存锁定',
|
||
created_at: new Date(),
|
||
});
|
||
}
|
||
|
||
if (unlockTransactionRows.length > 0) {
|
||
await ctx.model.StorageTransaction.bulkCreate(unlockTransactionRows, { 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<Object>} pickingRows 待补偿的拣货记录列表。
|
||
* @return {Promise<number>} 补偿成功的拣货记录数。
|
||
*/
|
||
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' 的记录
|
||
// 使用 FOR UPDATE 行锁,防止并发事务读取到相同的 picking 记录导致重复扣减库存
|
||
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 -- 排除软删除记录
|
||
FOR UPDATE
|
||
`, {
|
||
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;
|