WMS_MAIN/app/service/systems/pick_compensation.js
liufumingren 61b82512f2 feat(auth): 新增客服组权限授权/取消脚本,更新 dev-agent 配置
- 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 配置
2026-08-04 18:08:46 +08:00

744 lines
25 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

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

'use strict';
const 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;