- pendingOrder/orderStorageAllocation: 优先取显式传入的 warehouse_id,缺失时回退 getWarehouseId - deliveryOrder: buildExpressAllocateRequest 携带 warehouse_id,并补充自动分配开关判定日志
2559 lines
89 KiB
JavaScript
2559 lines
89 KiB
JavaScript
'use strict';
|
||
|
||
const MainService = require('../main');
|
||
|
||
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
|
||
const { isLockedOrderStatus } = require('../../lib/lock_guard');
|
||
|
||
const STORAGE_STATUS_FIN = 'fin';
|
||
const STORAGE_STATUS_ERROR = 'error';
|
||
const ORDER_STATUS_CANCEL = 'cancel';
|
||
const ORDER_STEP_EXCEPTION = 3;
|
||
const ALLOCATION_LOG_SAMPLE_LIMIT = 20;
|
||
|
||
/**
|
||
* 规范化块状日志的输出值。
|
||
*
|
||
* @param {unknown} payload 日志载荷。
|
||
* @param {WeakSet<object>} [seen] 循环引用跟踪集。
|
||
* @return {unknown} 规范化后的值。
|
||
*/
|
||
function normalizeAllocationLogPayload(payload, seen = new WeakSet()) {
|
||
if (payload instanceof Error) {
|
||
return {
|
||
name: payload.name,
|
||
message: payload.message,
|
||
stack: payload.stack,
|
||
};
|
||
}
|
||
|
||
if (payload === null || typeof payload !== 'object') {
|
||
if (typeof payload === 'bigint') {
|
||
return payload.toString();
|
||
}
|
||
|
||
return payload;
|
||
}
|
||
|
||
if (payload instanceof Date) {
|
||
return payload.toISOString();
|
||
}
|
||
|
||
if (seen.has(payload)) {
|
||
return '[Circular]';
|
||
}
|
||
|
||
seen.add(payload);
|
||
|
||
if (Array.isArray(payload)) {
|
||
return payload.map(item => normalizeAllocationLogPayload(item, seen));
|
||
}
|
||
|
||
const normalized = {};
|
||
for (const [ key, value ] of Object.entries(payload)) {
|
||
normalized[key] = normalizeAllocationLogPayload(value, seen);
|
||
}
|
||
|
||
return normalized;
|
||
}
|
||
|
||
/**
|
||
* 格式化块状日志文本。
|
||
*
|
||
* @param {string} title 日志标题。
|
||
* @param {unknown} payload 日志载荷。
|
||
* @return {string} 块状日志文本。
|
||
*/
|
||
function formatAllocationLogBlock(title, payload) {
|
||
const normalizedPayload = normalizeAllocationLogPayload(payload);
|
||
let payloadText;
|
||
|
||
if (typeof normalizedPayload === 'string') {
|
||
payloadText = normalizedPayload;
|
||
} else {
|
||
try {
|
||
const stringifiedPayload = JSON.stringify(normalizedPayload, null, 2);
|
||
payloadText = stringifiedPayload === undefined ? String(payload) : stringifiedPayload;
|
||
} catch (error) {
|
||
payloadText = JSON.stringify({
|
||
message: error.message,
|
||
originalPayload: String(payload),
|
||
}, null, 2);
|
||
}
|
||
}
|
||
|
||
return [
|
||
'==============',
|
||
`时间:${Date.now()}`,
|
||
String(title || ''),
|
||
payloadText,
|
||
'==============',
|
||
].join('\n');
|
||
}
|
||
|
||
/**
|
||
* 输出块状文本日志。
|
||
*
|
||
* @param {string} title 日志标题。
|
||
* @param {unknown} payload 日志载荷。
|
||
* @return {void}
|
||
*/
|
||
function writeAllocationTextLog(title, payload) {
|
||
process.stdout.write(`${formatAllocationLogBlock(title, payload)}\n`);
|
||
}
|
||
|
||
/**
|
||
* 生成数组日志摘要,避免输出全量数据。
|
||
*
|
||
* @param {Array<unknown>} list 原始数组。
|
||
* @param {number} [limit=ALLOCATION_LOG_SAMPLE_LIMIT] 采样数量上限。
|
||
* @return {{count: number, sample: Array<unknown>}} 摘要信息。
|
||
*/
|
||
function summarizeArrayForLog(list, limit = ALLOCATION_LOG_SAMPLE_LIMIT) {
|
||
const normalizedList = Array.isArray(list) ? list : [];
|
||
|
||
return {
|
||
count: normalizedList.length,
|
||
sample: normalizedList.slice(0, limit),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 将输入值规范化为布尔值。
|
||
*
|
||
* @param {unknown} value 待转换的值。
|
||
* @param {boolean} [defaultValue=false] 空值时的默认布尔值。
|
||
* @return {boolean} 是否为真。
|
||
*/
|
||
function normalizeBooleanFlag(value, defaultValue = false) {
|
||
if (value === undefined || value === null || value === '') {
|
||
return defaultValue;
|
||
}
|
||
|
||
if (typeof value === 'boolean') {
|
||
return value;
|
||
}
|
||
|
||
if (typeof value === 'number') {
|
||
return value === 1;
|
||
}
|
||
|
||
if (typeof value === 'string') {
|
||
return [ '1', 'Y', 'YES', 'TRUE', 'ON' ].includes(value.trim().toUpperCase());
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 将输入值转换为有限数字。
|
||
*
|
||
* @param {unknown} value 待转换的值。
|
||
* @param {number} [defaultValue=0] 默认值。
|
||
* @return {number} 转换后的数字。
|
||
*/
|
||
function toNumber(value, defaultValue = 0) {
|
||
const normalized = Number(value);
|
||
|
||
return Number.isFinite(normalized) ? normalized : defaultValue;
|
||
}
|
||
|
||
/**
|
||
* 将模型记录转换为普通对象。
|
||
*
|
||
* @param {unknown} record 模型记录。
|
||
* @return {Object|null} 普通对象。
|
||
*/
|
||
function toPlainRecord(record) {
|
||
if (!record) {
|
||
return null;
|
||
}
|
||
|
||
if (typeof record.get === 'function') {
|
||
return record.get({ plain: true });
|
||
}
|
||
|
||
return record;
|
||
}
|
||
|
||
/**
|
||
* 解析日期值并返回时间戳。
|
||
*
|
||
* @param {unknown} value 日期值。
|
||
* @return {number} 时间戳或 Number.MAX_SAFE_INTEGER。
|
||
*/
|
||
function toTimeValue(value) {
|
||
if (!value) {
|
||
return Number.MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
const timeValue = new Date(value).getTime();
|
||
return Number.isFinite(timeValue) ? timeValue : Number.MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
/**
|
||
* 生成储位库存摘要。
|
||
*
|
||
* @param {number|string} stockId 库存 ID。
|
||
* @param {Array<Object>} storageRows 储位库存列表。
|
||
* @return {Object} 储位库存摘要。
|
||
*/
|
||
function summarizeStorageRows(stockId, storageRows = []) {
|
||
const rows = Array.isArray(storageRows) ? storageRows : [];
|
||
const firstRow = rows[0] || {};
|
||
|
||
return {
|
||
stock_id: Number(stockId) || 0,
|
||
rowCount: rows.length,
|
||
availableQuantityTotal: rows.reduce((sum, row) => sum + toNumber(row.available_quantity, 0), 0),
|
||
enabledCount: rows.filter(row => normalizeBooleanFlag(row.is_enabled, true)).length,
|
||
firstStorageId: Number(firstRow.id) || 0,
|
||
firstSpaceId: Number(firstRow.space_id) || 0,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 对可分配库存按优先级排序。
|
||
*
|
||
* @param {Object} left 左侧库存。
|
||
* @param {Object} right 右侧库存。
|
||
* @return {number} 排序结果。
|
||
*/
|
||
function compareStorageRows(left, right) {
|
||
const leftHasProductionDate = Boolean(left.production_date);
|
||
const rightHasProductionDate = Boolean(right.production_date);
|
||
|
||
if (leftHasProductionDate !== rightHasProductionDate) {
|
||
return leftHasProductionDate ? -1 : 1;
|
||
}
|
||
|
||
if (leftHasProductionDate && rightHasProductionDate) {
|
||
const productionDiff = toTimeValue(left.production_date) - toTimeValue(right.production_date);
|
||
if (productionDiff !== 0) {
|
||
return productionDiff;
|
||
}
|
||
}
|
||
|
||
const inboundDiff = toTimeValue(left.inbound_time) - toTimeValue(right.inbound_time);
|
||
if (inboundDiff !== 0) {
|
||
return inboundDiff;
|
||
}
|
||
|
||
return toNumber(left.id, 0) - toNumber(right.id, 0);
|
||
}
|
||
|
||
/**
|
||
* 生成库位类型限制导致的缺货原因文本。
|
||
*
|
||
* @param {Object} diagnostics 库位类型限制统计。
|
||
* @param {number} diagnostics.totalRows 原始库位行数。
|
||
* @param {number} diagnostics.allowAllocationFilteredRows allow_allocation 过滤行数。
|
||
* @param {number} diagnostics.isActiveFilteredRows is_active 过滤行数。
|
||
* @return {string} 缺货原因文本。
|
||
*/
|
||
function buildLocationTypeRestrictionReason(diagnostics = {}) {
|
||
const totalRows = toNumber(diagnostics.totalRows, 0);
|
||
const allowAllocationFilteredRows = toNumber(diagnostics.allowAllocationFilteredRows, 0);
|
||
const isActiveFilteredRows = toNumber(diagnostics.isActiveFilteredRows, 0);
|
||
|
||
if (totalRows <= 0) {
|
||
return '';
|
||
}
|
||
|
||
const reasonParts = [];
|
||
|
||
if (allowAllocationFilteredRows > 0) {
|
||
reasonParts.push('库位类型不可分配');
|
||
}
|
||
|
||
if (isActiveFilteredRows > 0) {
|
||
reasonParts.push('库位类型未启用');
|
||
}
|
||
|
||
return reasonParts.join('/');
|
||
}
|
||
|
||
/**
|
||
* 诊断库存是否因库位类型限制导致无可分配库位。
|
||
*
|
||
* @param {Object} options 参数。
|
||
* @param {Object} options.ctx 请求上下文。
|
||
* @param {Object} options.Op Sequelize 操作符集合。
|
||
* @param {number} options.warehouseId 仓库 ID。
|
||
* @param {number} options.stockId 库存 ID。
|
||
* @param {Object} options.transaction 事务对象。
|
||
* @param {Map<number, Object>} options.cache 诊断缓存。
|
||
* @return {Promise<Object>} 诊断结果。
|
||
*/
|
||
async function diagnoseStorageTypeRestriction(options = {}) {
|
||
const {
|
||
ctx,
|
||
Op,
|
||
warehouseId,
|
||
stockId,
|
||
transaction,
|
||
cache,
|
||
} = options;
|
||
|
||
const normalizedStockId = toNumber(stockId, 0);
|
||
if (normalizedStockId <= 0 || !ctx || !Op) {
|
||
return {
|
||
totalRows: 0,
|
||
allowAllocationFilteredRows: 0,
|
||
isActiveFilteredRows: 0,
|
||
reason: '',
|
||
};
|
||
}
|
||
|
||
if (cache instanceof Map && cache.has(normalizedStockId)) {
|
||
return cache.get(normalizedStockId);
|
||
}
|
||
|
||
const rawStorageRows = await ctx.model.Storage.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
stock_id: normalizedStockId,
|
||
is_enabled: 1,
|
||
delete_at: null,
|
||
available_quantity: {
|
||
[Op.gt]: 0,
|
||
},
|
||
},
|
||
include: [
|
||
{
|
||
model: ctx.model.LocationSpace,
|
||
as: 'space',
|
||
required: true,
|
||
attributes: [ 'id' ],
|
||
include: [
|
||
{
|
||
model: ctx.model.LocationType,
|
||
as: 'locationType',
|
||
required: true,
|
||
attributes: [ 'id', 'allow_allocation', 'is_active' ],
|
||
},
|
||
],
|
||
},
|
||
],
|
||
transaction,
|
||
});
|
||
|
||
let allowAllocationFilteredRows = 0;
|
||
let isActiveFilteredRows = 0;
|
||
|
||
for (const storageRow of Array.isArray(rawStorageRows) ? rawStorageRows : []) {
|
||
const plainStorage = toPlainRecord(storageRow) || {};
|
||
const space = toPlainRecord(plainStorage.space) || {};
|
||
const locationType = toPlainRecord(space.locationType) || {};
|
||
|
||
if (toNumber(locationType.allow_allocation, 0) !== 1) {
|
||
allowAllocationFilteredRows += 1;
|
||
}
|
||
|
||
if (toNumber(locationType.is_active, 0) !== 1) {
|
||
isActiveFilteredRows += 1;
|
||
}
|
||
}
|
||
|
||
const diagnostics = {
|
||
totalRows: Array.isArray(rawStorageRows) ? rawStorageRows.length : 0,
|
||
allowAllocationFilteredRows,
|
||
isActiveFilteredRows,
|
||
reason: '',
|
||
};
|
||
|
||
diagnostics.reason = buildLocationTypeRestrictionReason(diagnostics);
|
||
|
||
if (cache instanceof Map) {
|
||
cache.set(normalizedStockId, diagnostics);
|
||
}
|
||
|
||
return diagnostics;
|
||
}
|
||
|
||
/**
|
||
* 生成库存不足提示文本。
|
||
*
|
||
* @param {Array<Object>} shortageItems 缺货条目。
|
||
* @return {string} 提示文本。
|
||
*/
|
||
function buildShortageMessage(shortageItems = []) {
|
||
const parts = shortageItems
|
||
.filter(item => item && Number(item.stock_id) > 0)
|
||
.map(item => {
|
||
const shortageReason = String(item.reason || '').trim();
|
||
const reasonText = shortageReason ? `,原因:${shortageReason}` : '';
|
||
|
||
return `sku(${item.stock_id}),数量:${item.required_quantity},库位数量:${item.allocated_quantity}${reasonText}`;
|
||
});
|
||
|
||
return parts.length > 0 ? `库存不足:${parts.join('|')}` : '';
|
||
}
|
||
|
||
/**
|
||
* 规范化订单 ID 列表。
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {number[]} 订单 ID 列表。
|
||
*/
|
||
function normalizeOrderIds(data = {}) {
|
||
const requestData = data && typeof data === 'object' ? data : {};
|
||
const rawValues = [];
|
||
|
||
if (Array.isArray(requestData.order_ids)) {
|
||
rawValues.push(...requestData.order_ids);
|
||
} else if (Array.isArray(requestData.orderIds)) {
|
||
rawValues.push(...requestData.orderIds);
|
||
} else if (Array.isArray(requestData.ids)) {
|
||
rawValues.push(...requestData.ids);
|
||
} else if (typeof requestData.order_ids === 'string') {
|
||
rawValues.push(...requestData.order_ids.split(','));
|
||
} else if (typeof requestData.orderIds === 'string') {
|
||
rawValues.push(...requestData.orderIds.split(','));
|
||
} else if (typeof requestData.ids === 'string') {
|
||
rawValues.push(...requestData.ids.split(','));
|
||
} else if (requestData.order_ids !== undefined && requestData.order_ids !== null && requestData.order_ids !== '') {
|
||
rawValues.push(requestData.order_ids);
|
||
} else if (requestData.orderIds !== undefined && requestData.orderIds !== null && requestData.orderIds !== '') {
|
||
rawValues.push(requestData.orderIds);
|
||
} else if (requestData.ids !== undefined && requestData.ids !== null && requestData.ids !== '') {
|
||
rawValues.push(requestData.ids);
|
||
} else if (requestData.order_id !== undefined && requestData.order_id !== null && requestData.order_id !== '') {
|
||
rawValues.push(requestData.order_id);
|
||
} else if (requestData.orderId !== undefined && requestData.orderId !== null && requestData.orderId !== '') {
|
||
rawValues.push(requestData.orderId);
|
||
} else if (requestData.id !== undefined && requestData.id !== null && requestData.id !== '') {
|
||
rawValues.push(requestData.id);
|
||
}
|
||
|
||
const orderIds = rawValues
|
||
.map(value => Number(String(value).trim()))
|
||
.filter(value => Number.isFinite(value) && value > 0);
|
||
|
||
return Array.from(new Set(orderIds));
|
||
}
|
||
|
||
/**
|
||
* 规范化取消储位分配相关入参。
|
||
*
|
||
* 仅保留订单 ID 归一化结果,不再接收或透传存储位开关字段。
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {{ orderIds: number[], forbiddenWarehouseKeys: string[] }} 规范化结果。
|
||
*/
|
||
function normalizeCancelStorageAllocationRequest(data = {}) {
|
||
const requestData = data && typeof data === 'object' ? data : {};
|
||
const forbiddenWarehouseKeys = [ 'warehouse_id', 'warehouseId' ]
|
||
.filter(key => Object.prototype.hasOwnProperty.call(requestData, key));
|
||
|
||
return {
|
||
orderIds: normalizeOrderIds(requestData),
|
||
forbiddenWarehouseKeys,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 订单储位分配公共服务。
|
||
* 负责订单、库存、库位的分配编排,并写入 wms_picking。
|
||
*/
|
||
class OrderStorageAllocationService extends MainService {
|
||
/**
|
||
* 按订单批量分配储位。
|
||
*
|
||
* 入参支持以下字段:
|
||
* - `allow_storage_location` / `allowStorageLocation` / `is_allow_storage` / `isAllowStorage`
|
||
* - `order_ids` / `orderIds` / `ids` / `order_id` / `orderId` / `id`
|
||
*
|
||
* 分配规则:
|
||
* - 先过滤掉已经完成储位分配的订单
|
||
* - 允许时优先使用存储储位,再使用分拣储位
|
||
* - FIFO 先按生产日期,再按入库时间
|
||
* - 库存不足时按订单顺序尽量分配,并将不足订单标记为异常
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 分配结果。
|
||
*/
|
||
async allocatePicking(data = {}) {
|
||
const { ctx, app } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const progressCallback = typeof requestData.progress_callback === 'function'
|
||
? requestData.progress_callback
|
||
: null;
|
||
// 优先使用调用方显式传入的仓库ID(Qimen 等无登录用户上下文的链路 ctx.user 为空)
|
||
const warehouseId = toNumber(
|
||
requestData.warehouse_id
|
||
?? requestData.warehouseId
|
||
?? ctx.user?.store_id
|
||
?? ctx.user?.warehouse_id,
|
||
0
|
||
);
|
||
const orderIds = normalizeOrderIds(requestData);
|
||
const allowStorageLocation = normalizeBooleanFlag(
|
||
requestData.allow_storage_location
|
||
?? requestData.allowStorageLocation
|
||
?? requestData.is_allow_storage
|
||
?? requestData.isAllowStorage
|
||
);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 入口入参', {
|
||
requestData,
|
||
warehouseId,
|
||
orderIds,
|
||
allowStorageLocation,
|
||
});
|
||
|
||
if (warehouseId <= 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 缺少仓库上下文,直接返回', {
|
||
requestData,
|
||
warehouseId,
|
||
orderIds,
|
||
allowStorageLocation,
|
||
});
|
||
return {
|
||
code: 400,
|
||
message: '缺少仓库上下文',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
if (orderIds.length === 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单ID为空,直接返回', {
|
||
requestData,
|
||
warehouseId,
|
||
orderIds,
|
||
allowStorageLocation,
|
||
});
|
||
return {
|
||
code: 400,
|
||
message: '订单ID不能为空',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
const transaction = await ctx.model.transaction();
|
||
const { Op } = app.Sequelize;
|
||
const now = new Date();
|
||
const notifyProgress = async payload => {
|
||
if (typeof progressCallback !== 'function') {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
await progressCallback(payload);
|
||
} catch (error) {
|
||
if (ctx.logger && typeof ctx.logger.warn === 'function') {
|
||
ctx.logger.warn('[OrderStorageAllocationService.allocatePicking] 上报进度回调失败: %s', error && error.message ? error.message : error);
|
||
}
|
||
}
|
||
};
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 事务已创建', {
|
||
warehouseId,
|
||
orderIds,
|
||
allowStorageLocation,
|
||
});
|
||
|
||
try {
|
||
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
|
||
const orderItemModel = await ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
|
||
const pickingModel = ctx.model.Picking;
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 模型加载完成', {
|
||
warehouseId,
|
||
hasOrderModel: Boolean(orderModel),
|
||
hasOrderItemModel: Boolean(orderItemModel),
|
||
hasPickingModel: Boolean(pickingModel),
|
||
});
|
||
|
||
if (!pickingModel || typeof pickingModel.bulkCreate !== 'function') {
|
||
throw new Error('wms_picking 模型不可用');
|
||
}
|
||
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
id: {
|
||
[Op.in]: orderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单主表查询完成', {
|
||
warehouseId,
|
||
requestedOrderCount: orderIds.length,
|
||
requestedOrderSampleIds: orderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
orderRowCount: Array.isArray(orderRows) ? orderRows.length : 0,
|
||
});
|
||
|
||
const orderMap = new Map();
|
||
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
|
||
const plainOrder = toPlainRecord(orderRow);
|
||
if (!plainOrder || !Number(plainOrder.id)) {
|
||
continue;
|
||
}
|
||
|
||
orderMap.set(Number(plainOrder.id), plainOrder);
|
||
}
|
||
|
||
const pendingOrderIds = [];
|
||
const skippedOrders = [];
|
||
const errorRetryOrderIds = [];
|
||
|
||
for (const orderId of orderIds) {
|
||
const orderRow = orderMap.get(orderId);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单前', {
|
||
orderId,
|
||
hasOrderRow: Boolean(orderRow),
|
||
storageStatus: orderRow ? orderRow.storage_status : null,
|
||
});
|
||
|
||
if (!orderRow) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
skipped_reason: 'not_found',
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单结果', {
|
||
orderId,
|
||
skippedReason: 'not_found',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (String(orderRow.status || '').trim() === ORDER_STATUS_CANCEL) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
order_status: orderRow.status,
|
||
skipped_reason: 'order_cancelled',
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单结果', {
|
||
orderId,
|
||
skippedReason: 'order_cancelled',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (isInterceptedOrderStatus(orderRow && orderRow.intercept_status)) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
intercept_status: orderRow.intercept_status,
|
||
skipped_reason: 'intercepted',
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单结果', {
|
||
orderId,
|
||
interceptStatus: orderRow.intercept_status,
|
||
skippedReason: 'intercepted',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (isLockedOrderStatus(orderRow && orderRow.lock_status)) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
lock_status: orderRow.lock_status,
|
||
skipped_reason: 'locked',
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单结果', {
|
||
orderId,
|
||
lockStatus: orderRow.lock_status,
|
||
skippedReason: 'locked',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (String(orderRow.storage_status || 'none') === STORAGE_STATUS_FIN) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
storage_status: orderRow.storage_status,
|
||
skipped_reason: 'already_allocated',
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 过滤订单结果', {
|
||
orderId,
|
||
skippedReason: 'already_allocated',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
pendingOrderIds.push(orderId);
|
||
|
||
if (String(orderRow.storage_status || 'none') === STORAGE_STATUS_ERROR) {
|
||
errorRetryOrderIds.push(orderId);
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单进入待分配列表', {
|
||
orderId,
|
||
storageStatus: orderRow.storage_status,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单过滤完成', {
|
||
requestedOrderCount: orderIds.length,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
skippedOrderCount: skippedOrders.length,
|
||
errorRetryOrderCount: errorRetryOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
skippedOrderSample: skippedOrders.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
errorRetryOrderSampleIds: errorRetryOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
|
||
if (pendingOrderIds.length === 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 无需分配的订单,准备提交事务', {
|
||
warehouseId,
|
||
skippedOrderCount: skippedOrders.length,
|
||
skippedOrderSample: skippedOrders.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
await transaction.commit();
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 事务提交完成', {
|
||
warehouseId,
|
||
requestedOrderCount: orderIds.length,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
skippedOrderCount: skippedOrders.length,
|
||
requestedOrderSampleIds: orderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
skippedOrderSample: skippedOrders.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
return {
|
||
code: 200,
|
||
message: '没有需要分配的订单',
|
||
data: {
|
||
warehouse_id: warehouseId,
|
||
allow_storage_location: allowStorageLocation,
|
||
requested_order_ids: orderIds,
|
||
pending_order_ids: [],
|
||
skipped_orders: skippedOrders,
|
||
orders: skippedOrders,
|
||
picking_count: 0,
|
||
},
|
||
};
|
||
}
|
||
|
||
const orderItemRows = await orderItemModel.findAll({
|
||
where: {
|
||
order_id: {
|
||
[Op.in]: pendingOrderIds,
|
||
},
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单明细查询完成', {
|
||
warehouseId,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
orderItemRowCount: Array.isArray(orderItemRows) ? orderItemRows.length : 0,
|
||
});
|
||
|
||
const orderItemsByOrderId = new Map();
|
||
const stockIdSet = new Set();
|
||
|
||
for (const orderItemRow of Array.isArray(orderItemRows) ? orderItemRows : []) {
|
||
const plainItem = toPlainRecord(orderItemRow);
|
||
if (!plainItem || !Number(plainItem.order_id)) {
|
||
continue;
|
||
}
|
||
|
||
const orderId = Number(plainItem.order_id);
|
||
const orderItems = orderItemsByOrderId.get(orderId) || [];
|
||
orderItems.push(plainItem);
|
||
orderItemsByOrderId.set(orderId, orderItems);
|
||
|
||
const stockId = Number(plainItem.stock_id || 0);
|
||
if (stockId > 0) {
|
||
stockIdSet.add(stockId);
|
||
}
|
||
}
|
||
|
||
const stockIds = Array.from(stockIdSet);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单明细归集完成', {
|
||
warehouseId,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
stockIdCount: stockIds.length,
|
||
stockIdSample: stockIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
|
||
if (stockIds.length > 0) {
|
||
await ctx.model.StockWarehouse.findAll({
|
||
where: {
|
||
id: {
|
||
[Op.in]: stockIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
is_valid: 'Y',
|
||
deleted_at: null,
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 库存主记录预锁定完成', {
|
||
warehouseId,
|
||
stockIdCount: stockIds.length,
|
||
stockIdSample: stockIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
});
|
||
|
||
const storageRows = stockIds.length > 0
|
||
? await ctx.model.Storage.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
stock_id: {
|
||
[Op.in]: stockIds,
|
||
},
|
||
is_enabled: 1,
|
||
delete_at: null,
|
||
available_quantity: {
|
||
[Op.gt]: 0,
|
||
},
|
||
},
|
||
include: [
|
||
{
|
||
model: ctx.model.LocationSpace,
|
||
as: 'space',
|
||
required: true,
|
||
attributes: [ 'id', 'space_code', 'custom_name', 'pick_sequence', 'pick_priority' ],
|
||
include: [
|
||
{
|
||
model: ctx.model.LocationType,
|
||
as: 'locationType',
|
||
required: true,
|
||
attributes: [ 'id', 'type_code', 'type_name', 'allow_allocation', 'is_active' ],
|
||
where: {
|
||
allow_allocation: 1,
|
||
is_active: 1,
|
||
},
|
||
},
|
||
],
|
||
},
|
||
],
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
order: [[ 'id', 'ASC' ]],
|
||
})
|
||
: [];
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 可分配库存查询完成', {
|
||
warehouseId,
|
||
stockIdCount: stockIds.length,
|
||
stockIdSample: stockIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
storageRowCount: Array.isArray(storageRows) ? storageRows.length : 0,
|
||
});
|
||
|
||
const storageRowsByStockId = new Map();
|
||
for (const storageRow of Array.isArray(storageRows) ? storageRows : []) {
|
||
const plainStorage = toPlainRecord(storageRow);
|
||
if (!plainStorage || !Number(plainStorage.id) || !Number(plainStorage.stock_id)) {
|
||
continue;
|
||
}
|
||
|
||
const space = toPlainRecord(plainStorage.space) || {};
|
||
const locationType = toPlainRecord(space.locationType) || {};
|
||
const normalizedStorage = {
|
||
...plainStorage,
|
||
quantity: toNumber(plainStorage.quantity, 0),
|
||
locked_quantity: toNumber(plainStorage.locked_quantity, 0),
|
||
available_quantity: toNumber(plainStorage.available_quantity, 0),
|
||
production_date: plainStorage.production_date || null,
|
||
inbound_time: plainStorage.inbound_time || null,
|
||
space,
|
||
locationType,
|
||
space_name: String(space.custom_name || space.space_code || '').trim(),
|
||
};
|
||
|
||
const stockId = Number(normalizedStorage.stock_id);
|
||
const currentStorageRows = storageRowsByStockId.get(stockId) || [];
|
||
currentStorageRows.push(normalizedStorage);
|
||
storageRowsByStockId.set(stockId, currentStorageRows);
|
||
}
|
||
|
||
for (const [ stockId, storageRowsForStock ] of storageRowsByStockId.entries()) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 库存可分配摘要', summarizeStorageRows(stockId, storageRowsForStock));
|
||
}
|
||
|
||
const policyCache = new Map();
|
||
const shortageReasonCache = new Map();
|
||
const pickingRows = [];
|
||
const storageAllocationMap = new Map();
|
||
const orderResults = [];
|
||
const totalCount = pendingOrderIds.length;
|
||
let processedCount = 0;
|
||
|
||
// 按订单维度跟踪已锁定的库存记录,用于缺货订单的原子回滚。
|
||
// Map<orderId, Array<{ storageId: number, quantity: number }>>
|
||
const orderLockRecords = new Map();
|
||
|
||
// 对于 storage_status='error' 的重分配订单,先清理旧的 picking 记录并释放已锁定的库存
|
||
if (errorRetryOrderIds.length > 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 检测到 error 重试订单,开始清理旧数据', {
|
||
warehouseId,
|
||
errorRetryOrderIds,
|
||
errorRetryOrderCount: errorRetryOrderIds.length,
|
||
});
|
||
|
||
const oldPickingRecords = await pickingModel.findAll({
|
||
where: {
|
||
order_id: { [Op.in]: errorRetryOrderIds },
|
||
status: 'pending',
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 查询到旧的 picking 记录', {
|
||
warehouseId,
|
||
oldPickingCount: Array.isArray(oldPickingRecords) ? oldPickingRecords.length : 0,
|
||
});
|
||
|
||
if (Array.isArray(oldPickingRecords) && oldPickingRecords.length > 0) {
|
||
for (const record of oldPickingRecords) {
|
||
const storageId = toNumber(record.storage_id, 0);
|
||
const quantity = toNumber(record.quantity, 0);
|
||
|
||
if (storageId > 0 && quantity > 0) {
|
||
await ctx.service.systems.storage.index.unlockQuantity(storageId, quantity, { transaction });
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 已释放旧库存锁定', {
|
||
warehouseId,
|
||
orderId: toNumber(record.order_id, 0),
|
||
storageId,
|
||
quantity,
|
||
});
|
||
}
|
||
}
|
||
|
||
await pickingModel.destroy({
|
||
where: {
|
||
order_id: { [Op.in]: errorRetryOrderIds },
|
||
status: 'pending',
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 已删除旧的 picking 记录', {
|
||
warehouseId,
|
||
errorRetryOrderIds,
|
||
deletedCount: oldPickingRecords.length,
|
||
});
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] error 订单旧数据清理完成', {
|
||
warehouseId,
|
||
errorRetryOrderIds,
|
||
});
|
||
}
|
||
|
||
await notifyProgress({
|
||
status: 'running',
|
||
total_count: totalCount,
|
||
processed_count: processedCount,
|
||
});
|
||
|
||
for (const orderId of pendingOrderIds) {
|
||
const orderRow = orderMap.get(orderId);
|
||
if (!orderRow) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 处理订单时发现订单缺失', {
|
||
orderId,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 开始处理订单', {
|
||
orderId,
|
||
orderRow,
|
||
});
|
||
|
||
const orderItems = (orderItemsByOrderId.get(orderId) || [])
|
||
.slice()
|
||
.sort((left, right) => {
|
||
const leftLineNo = toNumber(left.order_line_no, 0);
|
||
const rightLineNo = toNumber(right.order_line_no, 0);
|
||
|
||
if (leftLineNo !== rightLineNo) {
|
||
return leftLineNo - rightLineNo;
|
||
}
|
||
|
||
return toNumber(left.id, 0) - toNumber(right.id, 0);
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单明细准备完成', {
|
||
orderId,
|
||
orderItemCount: orderItems.length,
|
||
orderItemIds: orderItems.map(item => toNumber(item.id, 0)),
|
||
});
|
||
|
||
const shortageItems = [];
|
||
const storageRowErrors = [];
|
||
let allocatedQuantityForOrder = 0;
|
||
|
||
for (const orderItem of orderItems) {
|
||
const stockId = toNumber(orderItem.stock_id, 0);
|
||
const requiredQuantity = toNumber(orderItem.plan_qty ?? orderItem.planQty ?? orderItem.count ?? 0, 0);
|
||
|
||
if (stockId <= 0 || requiredQuantity <= 0) {
|
||
shortageItems.push({
|
||
stock_id: stockId,
|
||
required_quantity: requiredQuantity > 0 ? requiredQuantity : 0,
|
||
allocated_quantity: 0,
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单明细无效或缺少库存,记为缺货', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
requiredQuantity,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const policyEntry = policyCache.has(stockId)
|
||
? policyCache.get(stockId)
|
||
: await ctx.service.systems.stockStore.getStoreWarehousePolicyConfigByStockId(stockId, transaction);
|
||
policyCache.set(stockId, policyEntry);
|
||
|
||
const storageSeparationEnabled = normalizeBooleanFlag(policyEntry?.policyConfig?.storage_separation, true);
|
||
const allowStorageSpace = allowStorageLocation || !storageSeparationEnabled;
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 读取库存策略完成', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
policyEntry,
|
||
storage_separation: policyEntry?.policyConfig?.storage_separation,
|
||
allowStorageLocation,
|
||
storageSeparationEnabled,
|
||
allowStorageSpace,
|
||
});
|
||
|
||
const storageRowsForStock = storageRowsByStockId.get(stockId) || [];
|
||
const candidateStorageRows = storageRowsForStock
|
||
.slice()
|
||
.sort((left, right) => compareStorageRows(left, right));
|
||
|
||
let shortageReason = '';
|
||
let shortageDiagnostics = null;
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 计算候选库存完成', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageRowCountBeforeFilter: storageRowsForStock.length,
|
||
candidateStorageRowCountAfterFilter: candidateStorageRows.length,
|
||
allowStorageSpace,
|
||
candidateStorageIds: candidateStorageRows.map(storageRow => storageRow.id),
|
||
});
|
||
|
||
if (candidateStorageRows.length === 0) {
|
||
shortageDiagnostics = await diagnoseStorageTypeRestriction({
|
||
ctx,
|
||
Op,
|
||
warehouseId,
|
||
stockId,
|
||
transaction,
|
||
cache: shortageReasonCache,
|
||
});
|
||
shortageReason = String(shortageDiagnostics.reason || '').trim();
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 无候选库位,标记缺货原因', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
requiredQuantity,
|
||
policyEntry: {
|
||
storage_separation: policyEntry?.policyConfig?.storage_separation,
|
||
allow_storage_location: policyEntry?.policyConfig?.allow_storage_location,
|
||
},
|
||
storageRowsSummary: summarizeStorageRows(stockId, storageRowsForStock),
|
||
allowStorageSpace,
|
||
shortageDiagnostics,
|
||
shortageReason,
|
||
});
|
||
}
|
||
|
||
let remainingQuantity = requiredQuantity;
|
||
let allocatedQuantityForItem = 0;
|
||
|
||
for (const storageRow of candidateStorageRows) {
|
||
if (remainingQuantity <= 0) {
|
||
break;
|
||
}
|
||
|
||
const currentAvailable = toNumber(storageRow.available_quantity, 0);
|
||
if (currentAvailable <= 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 候选库存已无可用数量,跳过', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageId: storageRow.id,
|
||
currentAvailable,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const allocationQuantity = Math.min(remainingQuantity, currentAvailable);
|
||
if (allocationQuantity <= 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 计算出的分配数量无效,跳过', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageId: storageRow.id,
|
||
currentAvailable,
|
||
remainingQuantity,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 准备锁定库存', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageId: storageRow.id,
|
||
storageRowSummary: {
|
||
storageId: storageRow.id,
|
||
spaceId: toNumber(storageRow.space_id, 0) || 0,
|
||
availableQuantity: currentAvailable,
|
||
lockedQuantity: toNumber(storageRow.locked_quantity, 0),
|
||
productionDate: storageRow.production_date || null,
|
||
inboundTime: storageRow.inbound_time || null,
|
||
},
|
||
allocationQuantity,
|
||
remainingQuantity,
|
||
currentAvailable,
|
||
});
|
||
|
||
const beforeLockedQuantity = toNumber(storageRow.locked_quantity, 0);
|
||
|
||
await ctx.service.systems.storage.index.lockQuantity(storageRow.id, allocationQuantity, { transaction });
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 库存锁定完成', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageId: storageRow.id,
|
||
allocationQuantity,
|
||
});
|
||
|
||
// 写入储位锁定流水
|
||
await ctx.model.StorageTransaction.create({
|
||
transaction_type: 'LOCK',
|
||
warehouse_id: warehouseId,
|
||
store_id: storageRow.store_id,
|
||
stock_id: stockId,
|
||
storage_id: storageRow.id,
|
||
space_id: storageRow.space_id,
|
||
quantity: allocationQuantity,
|
||
before_quantity: storageRow.quantity,
|
||
after_quantity: storageRow.quantity,
|
||
before_locked_quantity: beforeLockedQuantity,
|
||
after_locked_quantity: beforeLockedQuantity + allocationQuantity,
|
||
batch_no: storageRow.batch_no,
|
||
inventory_type: storageRow.inventory_type,
|
||
order_type: 'PICKING_LOCK',
|
||
order_no: String(orderId),
|
||
order_id: orderId,
|
||
operator_id: String(ctx.user?.employees_id ?? ctx.user?.id ?? ''),
|
||
operator_name: ctx.user?.employees_name ?? ctx.user?.real_name ?? ctx.user?.name ?? '',
|
||
remark: '分配储位(库存锁定)',
|
||
}, { transaction });
|
||
|
||
storageRow.available_quantity = currentAvailable - allocationQuantity;
|
||
storageRow.locked_quantity = toNumber(storageRow.locked_quantity, 0) + allocationQuantity;
|
||
remainingQuantity -= allocationQuantity;
|
||
allocatedQuantityForItem += allocationQuantity;
|
||
allocatedQuantityForOrder += allocationQuantity;
|
||
|
||
storageAllocationMap.set(storageRow.id, (storageAllocationMap.get(storageRow.id) || 0) + allocationQuantity);
|
||
|
||
const spaceId = toNumber(storageRow.space_id, 0);
|
||
if (!spaceId) {
|
||
storageRowErrors.push({ storage_id: storageRow.id, reason: '库位未设置' });
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 库位无效,跳过该库存行', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
storageId: storageRow.id,
|
||
spaceId: storageRow.space_id,
|
||
});
|
||
// 释放刚才 lockQuantity 加的锁,防止 locked_quantity 泄漏
|
||
await ctx.service.systems.storage.index.unlockQuantity(
|
||
storageRow.id, allocationQuantity, { transaction }
|
||
);
|
||
|
||
// 回退内存计数器:storageRow 的 available_quantity 和 locked_quantity
|
||
storageRow.available_quantity = currentAvailable;
|
||
storageRow.locked_quantity = toNumber(storageRow.locked_quantity, 0) - allocationQuantity;
|
||
|
||
// 回退 remainingQuantity:未分配成功的数量加回去
|
||
remainingQuantity += allocationQuantity;
|
||
|
||
// 回退 allocatedQuantityForItem
|
||
allocatedQuantityForItem -= allocationQuantity;
|
||
|
||
// 回退 allocatedQuantityForOrder
|
||
allocatedQuantityForOrder -= allocationQuantity;
|
||
|
||
// 回退 storageAllocationMap 中的累加值
|
||
const prevStorageQty = storageAllocationMap.get(storageRow.id) || 0;
|
||
const newStorageQty = prevStorageQty - allocationQuantity;
|
||
if (newStorageQty <= 0) {
|
||
storageAllocationMap.delete(storageRow.id);
|
||
} else {
|
||
storageAllocationMap.set(storageRow.id, newStorageQty);
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 库位无效,回退内存计数器', {
|
||
orderId,
|
||
storageId: storageRow.id,
|
||
allocationQuantity,
|
||
prevStorageQty,
|
||
newStorageQty,
|
||
rollback: {
|
||
remainingQuantity,
|
||
allocatedQuantityForItem,
|
||
allocatedQuantityForOrder,
|
||
storageAvailableQuantity: storageRow.available_quantity,
|
||
storageLockedQuantity: storageRow.locked_quantity,
|
||
},
|
||
});
|
||
|
||
continue;
|
||
}
|
||
|
||
// 记录本次成功锁定(lockQuantity + spaceId 有效),用于订单级别缺货回滚
|
||
const orderLockList = orderLockRecords.get(orderId) || [];
|
||
orderLockList.push({ storageId: storageRow.id, stockId: storageRow.stock_id, quantity: allocationQuantity });
|
||
orderLockRecords.set(orderId, orderLockList);
|
||
|
||
pickingRows.push({
|
||
order_id: orderId,
|
||
order_item_id: toNumber(orderItem.id, 0),
|
||
warehouse_id: warehouseId,
|
||
storage_id: storageRow.id,
|
||
stock_id: toNumber(storageRow.stock_id, 0) || null,
|
||
quantity: allocationQuantity,
|
||
space_id: toNumber(storageRow.space_id, 0) || null,
|
||
space_name: String(storageRow.space_name || '').trim(),
|
||
status: 'pending',
|
||
created_at: now,
|
||
updated_at: now,
|
||
});
|
||
}
|
||
|
||
if (remainingQuantity > 0) {
|
||
// 确保每个明细的缺货原因独立计算,避免候选库位为空时的诊断原因
|
||
// 被错误地复用到候选库位非空但仍不足的明细上
|
||
const finalShortageReason = candidateStorageRows.length === 0
|
||
? shortageReason
|
||
: (shortageReason || '库存不足');
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 准备写入缺货条目', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
requiredQuantity,
|
||
allocatedQuantity: allocatedQuantityForItem,
|
||
remainingQuantity,
|
||
candidateCount: candidateStorageRows.length,
|
||
shortageReason,
|
||
finalShortageReason,
|
||
});
|
||
shortageItems.push({
|
||
stock_id: stockId,
|
||
required_quantity: requiredQuantity,
|
||
allocated_quantity: allocatedQuantityForItem,
|
||
reason: finalShortageReason,
|
||
});
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单明细存在缺货', {
|
||
orderId,
|
||
orderItemId: toNumber(orderItem.id, 0),
|
||
stockId,
|
||
requiredQuantity,
|
||
allocatedQuantityForItem,
|
||
remainingQuantity,
|
||
shortageReason,
|
||
finalShortageReason,
|
||
});
|
||
}
|
||
}
|
||
|
||
const shortageMessage = buildShortageMessage(shortageItems);
|
||
|
||
const spaceErrorMessage = storageRowErrors.length > 0 && shortageMessage
|
||
? `库位未设置(storage_id:${storageRowErrors.map(e => e.storage_id).join(',')})`
|
||
: '';
|
||
const finalShortageMessage = [ shortageMessage, spaceErrorMessage ].filter(Boolean).join('|');
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单缺货信息汇总', {
|
||
orderId,
|
||
shortageItems,
|
||
storageRowErrors,
|
||
shortageMessage,
|
||
finalShortageMessage,
|
||
});
|
||
|
||
// 单订单原子性分配:如果本订单有缺货,回滚该订单所有已成功锁定的库存,
|
||
// 并从 pickingRows 中移除该订单的所有记录,确保同一事务内该订单不留任何 locked_quantity。
|
||
if (finalShortageMessage) {
|
||
const orderLocks = orderLockRecords.get(orderId);
|
||
if (Array.isArray(orderLocks) && orderLocks.length > 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 开始回滚订单已锁定库存', {
|
||
orderId,
|
||
orderLockCount: orderLocks.length,
|
||
orderLocks,
|
||
});
|
||
|
||
for (const lockRecord of orderLocks) {
|
||
await ctx.service.systems.storage.index.unlockQuantity(
|
||
lockRecord.storageId, lockRecord.quantity, { transaction }
|
||
);
|
||
|
||
// 回退 storageAllocationMap 中的累加值
|
||
const prevStorageQty = storageAllocationMap.get(lockRecord.storageId) || 0;
|
||
const newStorageQty = prevStorageQty - lockRecord.quantity;
|
||
if (newStorageQty <= 0) {
|
||
storageAllocationMap.delete(lockRecord.storageId);
|
||
} else {
|
||
storageAllocationMap.set(lockRecord.storageId, newStorageQty);
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 已回滚单条库存锁定', {
|
||
orderId,
|
||
storageId: lockRecord.storageId,
|
||
quantity: lockRecord.quantity,
|
||
prevStorageQty,
|
||
newStorageQty,
|
||
});
|
||
}
|
||
|
||
// 回退订单级别的已分配数量计数器
|
||
allocatedQuantityForOrder = 0;
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单锁定库存回滚完成,已重置 allocatedQuantityForOrder', {
|
||
orderId,
|
||
});
|
||
}
|
||
|
||
// 从 pickingRows 中移除该订单的所有记录。
|
||
// 使用反向遍历 + splice 避免索引漂移,保持 pickingRows 顺序。
|
||
for (let pickIdx = pickingRows.length - 1; pickIdx >= 0; pickIdx -= 1) {
|
||
if (pickingRows[pickIdx].order_id === orderId) {
|
||
pickingRows.splice(pickIdx, 1);
|
||
}
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 已从 pickingRows 移除缺货订单记录', {
|
||
orderId,
|
||
remainingPickingCount: pickingRows.length,
|
||
});
|
||
}
|
||
|
||
const orderUpdateValues = finalShortageMessage
|
||
? {
|
||
storage_status: STORAGE_STATUS_ERROR,
|
||
step: ORDER_STEP_EXCEPTION,
|
||
order_flag: finalShortageMessage,
|
||
updated_at: now,
|
||
}
|
||
: {
|
||
storage_status: STORAGE_STATUS_FIN,
|
||
order_flag: '',
|
||
updated_at: now,
|
||
};
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 准备更新订单状态', {
|
||
orderId,
|
||
orderUpdateValues,
|
||
allocatedQuantityForOrder,
|
||
});
|
||
|
||
await orderModel.update(orderUpdateValues, {
|
||
where: {
|
||
id: orderId,
|
||
warehouse_id: warehouseId,
|
||
status: {
|
||
[ctx.app.Sequelize.Op.ne]: 'cancel',
|
||
},
|
||
},
|
||
transaction,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 订单状态更新完成', {
|
||
orderId,
|
||
orderUpdateValues,
|
||
});
|
||
|
||
orderResults.push({
|
||
order_id: orderId,
|
||
storage_status: orderUpdateValues.storage_status,
|
||
allocated_quantity: allocatedQuantityForOrder,
|
||
shortage_message: finalShortageMessage || '',
|
||
status: finalShortageMessage ? 'error' : 'success',
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 当前订单处理结束', {
|
||
orderId,
|
||
orderResult: orderResults[orderResults.length - 1],
|
||
});
|
||
|
||
processedCount += 1;
|
||
await notifyProgress({
|
||
status: 'running',
|
||
total_count: totalCount,
|
||
processed_count: processedCount,
|
||
});
|
||
}
|
||
|
||
if (pickingRows.length > 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 写入 picking 明细', {
|
||
warehouseId,
|
||
pickingCount: pickingRows.length,
|
||
});
|
||
await pickingModel.bulkCreate(pickingRows, {
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 准备提交事务', {
|
||
warehouseId,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
skippedOrderCount: skippedOrders.length,
|
||
skippedOrderSample: skippedOrders.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
orderResultSummary: summarizeArrayForLog(orderResults),
|
||
stockLockSummary: [],
|
||
storageLockSummary: summarizeArrayForLog(Array.from(storageAllocationMap.entries()).map(([ storageId, quantity ]) => ({
|
||
storage_id: storageId,
|
||
locked_quantity: quantity,
|
||
}))),
|
||
});
|
||
|
||
await transaction.commit();
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 事务提交完成', {
|
||
warehouseId,
|
||
pendingOrderCount: pendingOrderIds.length,
|
||
pendingOrderSampleIds: pendingOrderIds.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
skippedOrderCount: skippedOrders.length,
|
||
skippedOrderSample: skippedOrders.slice(0, ALLOCATION_LOG_SAMPLE_LIMIT),
|
||
orderResultSummary: summarizeArrayForLog(orderResults),
|
||
});
|
||
|
||
const errorOrderResults = orderResults.filter(item => item.status === 'error');
|
||
const successOrderResults = orderResults.filter(item => item.status === 'success');
|
||
const successOrderIds = successOrderResults
|
||
.map(item => toNumber(item.order_id, 0))
|
||
.filter(orderId => orderId > 0);
|
||
|
||
if (successOrderIds.length > 0) {
|
||
try {
|
||
await ctx.service.systems.orderPendingException.reversePendingException({
|
||
ids: successOrderIds,
|
||
});
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 待处理异常清理完成', {
|
||
warehouseId,
|
||
successOrderIds,
|
||
});
|
||
} catch (reverseError) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 待处理异常清理失败,仅记录日志', {
|
||
warehouseId,
|
||
successOrderIds,
|
||
error: reverseError,
|
||
});
|
||
|
||
if (ctx.logger && typeof ctx.logger.error === 'function') {
|
||
ctx.logger.error('[OrderStorageAllocationService.allocatePicking] reversePendingException failed', {
|
||
warehouseId,
|
||
successOrderIds,
|
||
error: reverseError,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
const shortageMessages = errorOrderResults
|
||
.map(item => item.shortage_message)
|
||
.filter(Boolean);
|
||
|
||
const responseData = {
|
||
warehouse_id: warehouseId,
|
||
allow_storage_location: allowStorageLocation,
|
||
requested_order_ids: orderIds,
|
||
pending_order_ids: pendingOrderIds,
|
||
allocated_order_ids: successOrderResults.map(item => item.order_id),
|
||
shortage_order_ids: errorOrderResults.map(item => item.order_id),
|
||
skipped_orders: skippedOrders,
|
||
orders: [ ...skippedOrders, ...orderResults ],
|
||
picking_count: pickingRows.length,
|
||
stock_lock_summary: [],
|
||
storage_lock_summary: Array.from(storageAllocationMap.entries()).map(([ storageId, quantity ]) => ({
|
||
storage_id: storageId,
|
||
locked_quantity: quantity,
|
||
})),
|
||
shortage_messages: shortageMessages,
|
||
};
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 最终返回摘要', {
|
||
code: 200,
|
||
message: shortageMessages.length > 0
|
||
? '储位分配完成,部分订单库存不足'
|
||
: '储位分配完成',
|
||
responseDataSummary: {
|
||
requestedOrderIds: summarizeArrayForLog(responseData.requested_order_ids),
|
||
pendingOrderIds: summarizeArrayForLog(responseData.pending_order_ids),
|
||
allocatedOrderIds: summarizeArrayForLog(responseData.allocated_order_ids),
|
||
shortageOrderIds: summarizeArrayForLog(responseData.shortage_order_ids),
|
||
skippedOrders: summarizeArrayForLog(responseData.skipped_orders),
|
||
orders: summarizeArrayForLog(responseData.orders),
|
||
stockLockSummary: [],
|
||
storageLockSummary: summarizeArrayForLog(responseData.storage_lock_summary),
|
||
shortageMessages: summarizeArrayForLog(responseData.shortage_messages),
|
||
pickingCount: responseData.picking_count,
|
||
},
|
||
});
|
||
|
||
return {
|
||
code: 200,
|
||
message: shortageMessages.length > 0
|
||
? '储位分配完成,部分订单库存不足'
|
||
: '储位分配完成',
|
||
data: responseData,
|
||
};
|
||
} catch (error) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 发生异常,准备回滚事务', {
|
||
warehouseId,
|
||
orderIds,
|
||
error,
|
||
});
|
||
await transaction.rollback();
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocatePicking] 事务回滚完成', {
|
||
warehouseId,
|
||
orderIds,
|
||
error,
|
||
});
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 兼容旧调用名称的储位分配入口。
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 分配结果。
|
||
*/
|
||
async allocateStorage(data = {}) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocateStorage] 入口入参', data);
|
||
|
||
const result = await this.allocatePicking(data);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.allocateStorage] 返回结果', result);
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 待处理订单同步入口。
|
||
*
|
||
* 先完成订单查询、过滤与分组,再按 `create_channel` 路由到
|
||
* `orderAsync.syncQmOrders`、`orderAsync.syncManualOrders`、`orderAsync.syncApiOrders` 三个处理入口。
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 同步结果。
|
||
*/
|
||
async syncOrderIds(data = {}) {
|
||
const { ctx } = this;
|
||
const unallocatedPostStatus = 'none';
|
||
const fastFailReason = '快递状态未分配,禁止同步';
|
||
const snBatchForbiddenReason = 'SN订单不支持批量回传,请改用单订单回传';
|
||
const requestData = data && typeof data === 'object' ? data : {};
|
||
const normalizeNumber = (value, defaultValue = 0) => {
|
||
const numericValue = Number(value);
|
||
return Number.isFinite(numericValue) ? numericValue : defaultValue;
|
||
};
|
||
const normalizeOrderIds = request => {
|
||
const rawValues = [];
|
||
|
||
if (Array.isArray(request.order_ids)) {
|
||
rawValues.push(...request.order_ids);
|
||
} else if (Array.isArray(request.orderIds)) {
|
||
rawValues.push(...request.orderIds);
|
||
} else if (Array.isArray(request.ids)) {
|
||
rawValues.push(...request.ids);
|
||
} else if (typeof request.order_ids === 'string') {
|
||
rawValues.push(...request.order_ids.split(','));
|
||
} else if (typeof request.orderIds === 'string') {
|
||
rawValues.push(...request.orderIds.split(','));
|
||
} else if (typeof request.ids === 'string') {
|
||
rawValues.push(...request.ids.split(','));
|
||
} else if (request.order_ids !== undefined && request.order_ids !== null && request.order_ids !== '') {
|
||
rawValues.push(request.order_ids);
|
||
} else if (request.orderIds !== undefined && request.orderIds !== null && request.orderIds !== '') {
|
||
rawValues.push(request.orderIds);
|
||
} else if (request.ids !== undefined && request.ids !== null && request.ids !== '') {
|
||
rawValues.push(request.ids);
|
||
} else if (request.order_id !== undefined && request.order_id !== null && request.order_id !== '') {
|
||
rawValues.push(request.order_id);
|
||
} else if (request.orderId !== undefined && request.orderId !== null && request.orderId !== '') {
|
||
rawValues.push(request.orderId);
|
||
} else if (request.id !== undefined && request.id !== null && request.id !== '') {
|
||
rawValues.push(request.id);
|
||
}
|
||
|
||
const orderIds = rawValues
|
||
.map(value => Number(String(value).trim()))
|
||
.filter(value => Number.isFinite(value) && value > 0);
|
||
|
||
return Array.from(new Set(orderIds));
|
||
};
|
||
const normalizeCreateChannel = value => String(value || '').trim().toUpperCase() || 'MANUAL';
|
||
const toPlainRecord = record => {
|
||
if (!record) {
|
||
return null;
|
||
}
|
||
|
||
if (typeof record.get === 'function') {
|
||
return record.get({ plain: true });
|
||
}
|
||
|
||
return record;
|
||
};
|
||
const groupOrdersByCreateChannel = orders => {
|
||
const groupedOrderMap = new Map();
|
||
|
||
for (const order of Array.isArray(orders) ? orders : []) {
|
||
if (!order || typeof order !== 'object') {
|
||
continue;
|
||
}
|
||
|
||
const createChannel = normalizeCreateChannel(order.create_channel);
|
||
let groupedOrder = groupedOrderMap.get(createChannel);
|
||
|
||
if (!groupedOrder) {
|
||
groupedOrder = {
|
||
create_channel: createChannel,
|
||
order_ids: [],
|
||
order_count: 0,
|
||
orders: [],
|
||
};
|
||
groupedOrderMap.set(createChannel, groupedOrder);
|
||
}
|
||
|
||
const orderId = normalizeNumber(order.id, 0);
|
||
if (orderId > 0) {
|
||
groupedOrder.order_ids.push(orderId);
|
||
}
|
||
|
||
groupedOrder.order_count += 1;
|
||
groupedOrder.orders.push({
|
||
id: orderId,
|
||
delivery_order_code: String(order.delivery_order_code || '').trim(),
|
||
create_channel: createChannel,
|
||
sync_status: String(order.sync_status || '').trim() || 'padding',
|
||
express_code: String(order.express_code || '').trim(),
|
||
post_status: String(order.post_status || '').trim() || 'none',
|
||
storage_status: String(order.storage_status || '').trim() || 'none',
|
||
});
|
||
}
|
||
|
||
return Array.from(groupedOrderMap.values());
|
||
};
|
||
|
||
const orderIds = normalizeOrderIds(requestData);
|
||
// 优先使用调用方传入的 warehouse_id(异步模式下 ctx.user 可能失效),
|
||
// 兜底从 ctx.user 或 requestData 中读取
|
||
const warehouseId = normalizeNumber(
|
||
requestData.warehouse_id
|
||
?? ctx.user?.store_id
|
||
?? ctx.user?.warehouse_id,
|
||
0
|
||
);
|
||
const now = new Date();
|
||
// 请求ID(用于 Redis 进度缓存)
|
||
const requestId = String(requestData.request_id || requestData.requestId || '').trim();
|
||
|
||
if (warehouseId <= 0) {
|
||
return {
|
||
code: 400,
|
||
message: '缺少仓库上下文',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
if (orderIds.length === 0) {
|
||
return {
|
||
code: 400,
|
||
message: '订单ID不能为空',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
const transaction = await ctx.model.transaction();
|
||
|
||
try {
|
||
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
id: {
|
||
[ctx.app.Sequelize.Op.in]: orderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
// 排除已同步完成的订单,防止重复提交
|
||
// 注意:不能排除 padding,因为 padding 是新订单的默认值(模型 defaultValue)
|
||
sync_status: {
|
||
[ctx.app.Sequelize.Op.notIn]: [ 'fin' ],
|
||
},
|
||
// 排除已取消的订单,防止已取消订单被回传
|
||
status: {
|
||
[ctx.app.Sequelize.Op.notIn]: [ 'cancel' ],
|
||
},
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
const orderMap = new Map();
|
||
console.log('orderRows', JSON.stringify(orderRows));
|
||
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
|
||
const plainOrder = toPlainRecord(orderRow);
|
||
if (!plainOrder || !Number(plainOrder.id)) {
|
||
continue;
|
||
}
|
||
|
||
orderMap.set(Number(plainOrder.id), plainOrder);
|
||
}
|
||
|
||
// SN 管理订单不允许走批量回传:通过订单明细 stock_id 反查 stock_warehouse.is_sn_mgmt。
|
||
const snOrderIdSet = new Set();
|
||
const existingOrderIds = Array.from(orderMap.keys());
|
||
if (existingOrderIds.length > 0) {
|
||
try {
|
||
const orderItemModel = await ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
|
||
const stockModel = ctx.model.StockWarehouse;
|
||
|
||
if (orderItemModel && typeof orderItemModel.findAll === 'function' && stockModel && typeof stockModel.findAll === 'function') {
|
||
const orderItemRows = await orderItemModel.findAll({
|
||
where: {
|
||
order_id: {
|
||
[ctx.app.Sequelize.Op.in]: existingOrderIds,
|
||
},
|
||
},
|
||
attributes: [ 'order_id', 'stock_id' ],
|
||
raw: true,
|
||
});
|
||
|
||
const stockIds = [ ...new Set((Array.isArray(orderItemRows) ? orderItemRows : [])
|
||
.map(row => Number(row && row.stock_id || 0))
|
||
.filter(stockId => Number.isFinite(stockId) && stockId > 0)) ];
|
||
|
||
if (stockIds.length > 0) {
|
||
const stockRows = await stockModel.findAll({
|
||
where: {
|
||
id: {
|
||
[ctx.app.Sequelize.Op.in]: stockIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
},
|
||
attributes: [ 'id', 'is_sn_mgmt' ],
|
||
raw: true,
|
||
});
|
||
|
||
const snStockIdSet = new Set((Array.isArray(stockRows) ? stockRows : [])
|
||
.filter(row => String(row && row.is_sn_mgmt || '').trim().toUpperCase() === 'Y')
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(stockId => Number.isFinite(stockId) && stockId > 0));
|
||
|
||
for (const row of (Array.isArray(orderItemRows) ? orderItemRows : [])) {
|
||
const orderId = Number(row && row.order_id || 0);
|
||
const stockId = Number(row && row.stock_id || 0);
|
||
if (snStockIdSet.has(stockId) && orderId > 0) {
|
||
snOrderIdSet.add(orderId);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (snDetectError) {
|
||
ctx.logger.error('[OrderStorageAllocationService.syncOrderIds] SN订单检测失败', {
|
||
warehouseId,
|
||
orderIds: existingOrderIds,
|
||
message: snDetectError && snDetectError.message,
|
||
});
|
||
throw snDetectError;
|
||
}
|
||
}
|
||
|
||
const skippedOrders = [];
|
||
const fastFailedOrders = [];
|
||
const syncableOrders = [];
|
||
|
||
for (const orderId of orderIds) {
|
||
const orderRow = orderMap.get(orderId);
|
||
|
||
if (!orderRow) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
skipped_reason: 'not_found',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (String(orderRow.sync_status || '').trim() === 'fin') {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
create_channel: normalizeCreateChannel(orderRow.create_channel),
|
||
skipped_reason: 'already_synced',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
// SN 管理订单不允许走批量回传,标记为跳过,不阻断其他订单
|
||
if (snOrderIdSet.has(orderId)) {
|
||
fastFailedOrders.push({
|
||
order_id: orderId,
|
||
status: 'failed',
|
||
create_channel: normalizeCreateChannel(orderRow.create_channel),
|
||
failed_reason: 'sn_batch_forbidden',
|
||
message: snBatchForbiddenReason,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const normalizedPostStatus = String(orderRow.post_status || '').trim() || unallocatedPostStatus;
|
||
if (normalizedPostStatus === unallocatedPostStatus) {
|
||
fastFailedOrders.push({
|
||
order_id: orderId,
|
||
status: 'failed',
|
||
create_channel: normalizeCreateChannel(orderRow.create_channel),
|
||
post_status: normalizedPostStatus,
|
||
failed_reason: 'express_unallocated',
|
||
message: fastFailReason,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
syncableOrders.push(orderRow);
|
||
}
|
||
|
||
// SN 订单和快递未分配订单分开设置 sync_message
|
||
const snFailIds = fastFailedOrders
|
||
.filter(o => String(o && o.failed_reason || '').trim() === 'sn_batch_forbidden')
|
||
.map(o => normalizeNumber(o.order_id, 0))
|
||
.filter(id => id > 0);
|
||
const expressFailIds = fastFailedOrders
|
||
.filter(o => String(o && o.failed_reason || '').trim() === 'express_unallocated')
|
||
.map(o => normalizeNumber(o.order_id, 0))
|
||
.filter(id => id > 0);
|
||
|
||
const syncableOrderIds = syncableOrders
|
||
.map(order => normalizeNumber(order.id, 0))
|
||
.filter(orderId => orderId > 0);
|
||
const createChannelGroups = groupOrdersByCreateChannel(syncableOrders);
|
||
|
||
if (syncableOrderIds.length > 0) {
|
||
await orderModel.update({
|
||
sync_status: 'padding',
|
||
sync_message: '',
|
||
updated_at: now,
|
||
}, {
|
||
where: {
|
||
id: {
|
||
[ctx.app.Sequelize.Op.in]: syncableOrderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
if (snFailIds.length > 0) {
|
||
await orderModel.update({
|
||
sync_status: 'error',
|
||
sync_message: snBatchForbiddenReason,
|
||
inspection_status: STORAGE_STATUS_ERROR,
|
||
step: ORDER_STEP_EXCEPTION,
|
||
order_flag: snBatchForbiddenReason,
|
||
updated_at: now,
|
||
}, {
|
||
where: {
|
||
id: { [ctx.app.Sequelize.Op.in]: snFailIds },
|
||
warehouse_id: warehouseId,
|
||
status: { [ctx.app.Sequelize.Op.ne]: 'cancel' },
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
if (expressFailIds.length > 0) {
|
||
await orderModel.update({
|
||
sync_status: 'error',
|
||
sync_message: fastFailReason,
|
||
inspection_status: STORAGE_STATUS_ERROR,
|
||
step: ORDER_STEP_EXCEPTION,
|
||
order_flag: fastFailReason,
|
||
updated_at: now,
|
||
}, {
|
||
where: {
|
||
id: { [ctx.app.Sequelize.Op.in]: expressFailIds },
|
||
warehouse_id: warehouseId,
|
||
status: { [ctx.app.Sequelize.Op.ne]: 'cancel' },
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
if (snFailIds.length > 0 || expressFailIds.length > 0) {
|
||
ctx.logger.warn('[OrderStorageAllocationService.syncOrderIds] 命中快速失败,已阻断同步派发', {
|
||
warehouseId,
|
||
snFailIds,
|
||
expressFailIds,
|
||
});
|
||
}
|
||
|
||
await transaction.commit();
|
||
|
||
// ── 写初始进度到 Redis(dispatch handler 内部会递增 processed_count)──
|
||
if (requestId) {
|
||
const progressCacheKey = `order:pending:sync_order_ids:request:${requestId}`;
|
||
try {
|
||
await ctx.app.setCacheAsync(progressCacheKey, {
|
||
status: 'running',
|
||
total_count: syncableOrderIds.length,
|
||
processed_count: 0,
|
||
progress: 0,
|
||
warehouse_id: warehouseId,
|
||
update_time: Date.now(),
|
||
}, 7200);
|
||
} catch (cacheErr) {
|
||
ctx.logger.warn('[OrderStorageAllocationService.syncOrderIds] 初始化进度缓存失败', {
|
||
error: cacheErr && cacheErr.message,
|
||
});
|
||
}
|
||
}
|
||
|
||
const routeContext = {
|
||
warehouseId,
|
||
requestedOrderIds: orderIds,
|
||
pendingOrderIds: syncableOrderIds,
|
||
request_id: requestId,
|
||
};
|
||
const orderAsyncService = this.ctx.service.systems.orderAsync;
|
||
|
||
// 并行派发各渠道分组(每个分组独立 try/catch,单渠道异常不阻塞其他渠道)
|
||
const dispatchResults = await Promise.all(
|
||
createChannelGroups.map(async groupedOrder => {
|
||
const createChannel = normalizeCreateChannel(groupedOrder.create_channel);
|
||
const groupOrderCount = Number(groupedOrder.order_count || groupedOrder.order_ids?.length || 0);
|
||
|
||
try {
|
||
let result;
|
||
|
||
if (createChannel === 'QM') {
|
||
result = await orderAsyncService.syncQmOrders(groupedOrder, routeContext);
|
||
} else if (createChannel === 'API') {
|
||
result = await orderAsyncService.syncApiOrders(groupedOrder, routeContext);
|
||
} else {
|
||
result = await orderAsyncService.syncManualOrders(groupedOrder, routeContext);
|
||
}
|
||
|
||
const dispatchStatus = result && result.status
|
||
? String(result.status).trim() || 'success'
|
||
: (result && result.success === false ? 'failed' : 'success');
|
||
|
||
return {
|
||
...result,
|
||
status: dispatchStatus,
|
||
};
|
||
} catch (channelError) {
|
||
// 单渠道异常不影响其他渠道
|
||
ctx.logger.error('[OrderStorageAllocationService.syncOrderIds] 渠道派发异常,已隔离', {
|
||
createChannel,
|
||
warehouseId,
|
||
orderCount: groupOrderCount,
|
||
error: channelError && channelError.message ? channelError.message : channelError,
|
||
});
|
||
|
||
return {
|
||
create_channel: createChannel,
|
||
order_ids: Array.isArray(groupedOrder.order_ids) ? groupedOrder.order_ids : [],
|
||
order_count: groupOrderCount,
|
||
warehouse_id: warehouseId,
|
||
handler: 'syncOrderIds',
|
||
sync_target: createChannel === 'QM' ? 'qimen' : 'internal',
|
||
status: 'failed',
|
||
message: channelError && channelError.message ? channelError.message : '渠道派发异常',
|
||
success_count: 0,
|
||
failed_count: groupOrderCount,
|
||
route_state: 'rejected',
|
||
};
|
||
}
|
||
})
|
||
);
|
||
|
||
// 操作日志已移至 pendingOrder.syncOrderIds 层统一写入,避免重复
|
||
|
||
// 派发完成后,将成功渠道的订单 sync_status 更新为 fin,防止重复同步
|
||
const dispatchedOrderIds = [];
|
||
for (let i = 0; i < dispatchResults.length; i++) {
|
||
const dr = dispatchResults[i];
|
||
if (dr && String(dr.status || '').trim() === 'success') {
|
||
const group = createChannelGroups[i];
|
||
if (group && Array.isArray(group.order_ids)) {
|
||
for (const oid of group.order_ids) {
|
||
dispatchedOrderIds.push(Number(oid));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (dispatchedOrderIds.length > 0) {
|
||
try {
|
||
await orderModel.update({
|
||
sync_status: 'fin',
|
||
sync_message: '',
|
||
updated_at: new Date(),
|
||
}, {
|
||
where: {
|
||
id: { [ctx.app.Sequelize.Op.in]: dispatchedOrderIds },
|
||
warehouse_id: warehouseId,
|
||
},
|
||
});
|
||
ctx.logger.info('[OrderStorageAllocationService.syncOrderIds] 同步完成,已更新 sync_status=fin', {
|
||
warehouseId,
|
||
dispatchedCount: dispatchedOrderIds.length,
|
||
});
|
||
} catch (finUpdateErr) {
|
||
ctx.logger.error('[OrderStorageAllocationService.syncOrderIds] 更新 sync_status=fin 失败', {
|
||
warehouseId,
|
||
dispatchedCount: dispatchedOrderIds.length,
|
||
error: finUpdateErr && finUpdateErr.message,
|
||
});
|
||
}
|
||
}
|
||
|
||
const responseData = {
|
||
warehouse_id: warehouseId,
|
||
requested_order_ids: orderIds,
|
||
pending_order_ids: syncableOrderIds,
|
||
skipped_orders: skippedOrders,
|
||
create_channel_groups: createChannelGroups,
|
||
dispatch_results: dispatchResults,
|
||
failed_orders: fastFailedOrders,
|
||
orders: [
|
||
...skippedOrders,
|
||
...fastFailedOrders,
|
||
...syncableOrders.map(order => ({
|
||
order_id: normalizeNumber(order.id, 0),
|
||
delivery_order_code: String(order.delivery_order_code || '').trim(),
|
||
create_channel: normalizeCreateChannel(order.create_channel),
|
||
express_code: String(order.express_code || '').trim(),
|
||
sync_status: 'padding',
|
||
status: 'pending',
|
||
})),
|
||
],
|
||
pending_count: syncableOrderIds.length,
|
||
skipped_count: skippedOrders.length,
|
||
failed_count: fastFailedOrders.length,
|
||
create_channel_count: createChannelGroups.length,
|
||
dispatch_count: dispatchResults.length,
|
||
dispatch_success_count: dispatchResults.filter(item => item.status === 'success').length,
|
||
dispatch_failed_count: dispatchResults.filter(item => item.status === 'failed').length,
|
||
};
|
||
|
||
return {
|
||
code: 200,
|
||
message: syncableOrderIds.length > 0
|
||
? '同步已受理,已生成按来源分组的同步计划'
|
||
: (fastFailedOrders.length > 0 ? '同步失败:存在不允许批量回传的订单' : '没有需要同步的订单'),
|
||
data: responseData,
|
||
};
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 取消待处理订单的储位分配,并回滚相关库存锁定。
|
||
*
|
||
* 入参仅支持订单 ID 相关字段:
|
||
* - `order_ids` / `orderIds` / `ids` / `order_id` / `orderId` / `id`
|
||
*
|
||
* 取消分配时仅处理当前用户仓库中已完成储位分配的订单;
|
||
* 未分配订单或非完成状态订单会进入 skipped_orders。
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 取消分配结果。
|
||
*/
|
||
async cancelAllocateStorage(data = {}) {
|
||
const { ctx, app } = this;
|
||
const { orderIds, forbiddenWarehouseKeys } = normalizeCancelStorageAllocationRequest(data);
|
||
const warehouseId = toNumber(ctx.user?.store_id ?? ctx.user?.warehouse_id, 0);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 规范化入参', {
|
||
warehouseId,
|
||
orderIds,
|
||
forbiddenWarehouseKeys,
|
||
});
|
||
|
||
if (forbiddenWarehouseKeys.length > 0) {
|
||
throw new Error('待处理订单储位取消分配接口不再接受 warehouse_id / warehouseId,请使用当前用户仓库上下文');
|
||
}
|
||
|
||
if (warehouseId <= 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 缺少仓库上下文,直接返回', {
|
||
warehouseId,
|
||
orderIds,
|
||
});
|
||
return {
|
||
code: 400,
|
||
message: '缺少仓库上下文',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
if (orderIds.length === 0) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 订单ID为空,直接返回', {
|
||
warehouseId,
|
||
orderIds,
|
||
});
|
||
return {
|
||
code: 400,
|
||
message: '订单ID不能为空',
|
||
data: null,
|
||
};
|
||
}
|
||
|
||
const transaction = await ctx.model.transaction();
|
||
const { Op } = app.Sequelize;
|
||
const now = new Date();
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 事务已创建', {
|
||
warehouseId,
|
||
orderIds,
|
||
});
|
||
|
||
try {
|
||
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
|
||
const pickingModel = ctx.model.Picking;
|
||
const storageModel = ctx.model.Storage;
|
||
|
||
if (!pickingModel || typeof pickingModel.findAll !== 'function' || typeof pickingModel.destroy !== 'function') {
|
||
throw new Error('wms_picking 模型不可用');
|
||
}
|
||
|
||
if (!storageModel || typeof storageModel.findAll !== 'function') {
|
||
throw new Error('wms_storage 模型不可用');
|
||
}
|
||
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
id: {
|
||
[Op.in]: orderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
const orderMap = new Map();
|
||
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
|
||
const plainOrder = toPlainRecord(orderRow);
|
||
if (!plainOrder || !Number(plainOrder.id)) {
|
||
continue;
|
||
}
|
||
|
||
orderMap.set(Number(plainOrder.id), plainOrder);
|
||
}
|
||
|
||
const skippedOrders = [];
|
||
const eligibleOrderIds = [];
|
||
|
||
for (const orderId of orderIds) {
|
||
const orderRow = orderMap.get(orderId);
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 过滤订单前', {
|
||
orderId,
|
||
hasOrderRow: Boolean(orderRow),
|
||
storageStatus: orderRow ? orderRow.storage_status : null,
|
||
});
|
||
|
||
if (!orderRow) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
skipped_reason: 'not_found',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
if (String(orderRow.storage_status || 'none') !== STORAGE_STATUS_FIN) {
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
storage_status: orderRow.storage_status,
|
||
skipped_reason: 'not_allocated',
|
||
});
|
||
continue;
|
||
}
|
||
|
||
eligibleOrderIds.push(orderId);
|
||
}
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 订单过滤完成', {
|
||
requestedOrderIds: orderIds,
|
||
eligibleOrderIds,
|
||
skippedOrders,
|
||
});
|
||
|
||
if (eligibleOrderIds.length === 0) {
|
||
await transaction.commit();
|
||
return {
|
||
code: 200,
|
||
message: '没有需要取消分配的订单',
|
||
data: {
|
||
warehouse_id: warehouseId,
|
||
requested_order_ids: orderIds,
|
||
cancellable_order_ids: [],
|
||
skipped_orders: skippedOrders,
|
||
orders: skippedOrders,
|
||
picking_count: 0,
|
||
storage_unlock_summary: [],
|
||
storage_return_summary: [],
|
||
stock_unlock_summary: [],
|
||
},
|
||
};
|
||
}
|
||
|
||
const pickingRows = await pickingModel.findAll({
|
||
where: {
|
||
order_id: {
|
||
[Op.in]: eligibleOrderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
status: {
|
||
[Op.ne]: 'cancel',
|
||
},
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
const pickingRowsByOrderId = new Map();
|
||
const pendingStorageQuantityMap = new Map();
|
||
const finStorageQuantityMap = new Map();
|
||
const storageIdSet = new Set();
|
||
|
||
for (const pickingRow of Array.isArray(pickingRows) ? pickingRows : []) {
|
||
const plainPicking = toPlainRecord(pickingRow);
|
||
const orderId = toNumber(plainPicking?.order_id, 0);
|
||
const storageId = toNumber(plainPicking?.storage_id, 0);
|
||
const quantity = toNumber(plainPicking?.quantity, 0);
|
||
|
||
if (orderId <= 0 || storageId <= 0 || quantity <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const orderPickingRows = pickingRowsByOrderId.get(orderId) || [];
|
||
orderPickingRows.push(plainPicking);
|
||
pickingRowsByOrderId.set(orderId, orderPickingRows);
|
||
|
||
storageIdSet.add(storageId);
|
||
// 按状态分流:pending 记录解除锁定(实物不动);
|
||
// fin 记录(已拣货)返还实物数量,锁定已在拣货完成时扣减,不再重复扣除
|
||
const pickingStatus = String(plainPicking?.status || '').trim();
|
||
if (pickingStatus === 'fin') {
|
||
finStorageQuantityMap.set(storageId, (finStorageQuantityMap.get(storageId) || 0) + quantity);
|
||
} else {
|
||
pendingStorageQuantityMap.set(storageId, (pendingStorageQuantityMap.get(storageId) || 0) + quantity);
|
||
}
|
||
}
|
||
|
||
const cancellableOrderIds = [];
|
||
for (const orderId of eligibleOrderIds) {
|
||
if (pickingRowsByOrderId.has(orderId)) {
|
||
cancellableOrderIds.push(orderId);
|
||
continue;
|
||
}
|
||
|
||
skippedOrders.push({
|
||
order_id: orderId,
|
||
status: 'skipped',
|
||
storage_status: 'fin',
|
||
skipped_reason: 'no_allocation',
|
||
});
|
||
}
|
||
|
||
if (cancellableOrderIds.length === 0) {
|
||
await transaction.commit();
|
||
return {
|
||
code: 200,
|
||
message: '没有需要取消分配的订单',
|
||
data: {
|
||
warehouse_id: warehouseId,
|
||
requested_order_ids: orderIds,
|
||
cancellable_order_ids: [],
|
||
skipped_orders: skippedOrders,
|
||
orders: skippedOrders,
|
||
picking_count: 0,
|
||
storage_unlock_summary: [],
|
||
storage_return_summary: [],
|
||
stock_unlock_summary: [],
|
||
},
|
||
};
|
||
}
|
||
|
||
const storageRows = await storageModel.findAll({
|
||
where: {
|
||
id: {
|
||
[Op.in]: Array.from(storageIdSet),
|
||
},
|
||
warehouse_id: warehouseId,
|
||
},
|
||
transaction,
|
||
lock: transaction.LOCK.UPDATE,
|
||
raw: true,
|
||
});
|
||
|
||
const storageMap = new Map();
|
||
for (const storageRow of Array.isArray(storageRows) ? storageRows : []) {
|
||
const plainStorage = toPlainRecord(storageRow);
|
||
if (!plainStorage || !Number(plainStorage.id)) {
|
||
continue;
|
||
}
|
||
|
||
storageMap.set(Number(plainStorage.id), plainStorage);
|
||
}
|
||
|
||
const storageUnlockSummary = [];
|
||
const storageReturnSummary = [];
|
||
|
||
// pending 记录:解除锁定,实物库存不动
|
||
for (const [ storageId, quantity ] of pendingStorageQuantityMap.entries()) {
|
||
if (quantity <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const storageRow = storageMap.get(storageId);
|
||
if (!storageRow) {
|
||
throw new Error(`库存记录不存在: ${storageId}`);
|
||
}
|
||
|
||
const beforeLockedQuantity = toNumber(storageRow.locked_quantity, 0);
|
||
|
||
await ctx.service.systems.storage.index.unlockQuantity(storageId, quantity, {
|
||
transaction,
|
||
});
|
||
|
||
// 写入储位解锁流水
|
||
await ctx.model.StorageTransaction.create({
|
||
transaction_type: 'UNLOCK',
|
||
warehouse_id: warehouseId,
|
||
store_id: storageRow.store_id,
|
||
stock_id: storageRow.stock_id,
|
||
storage_id: storageId,
|
||
space_id: storageRow.space_id,
|
||
quantity,
|
||
before_quantity: storageRow.quantity,
|
||
after_quantity: storageRow.quantity,
|
||
before_locked_quantity: beforeLockedQuantity,
|
||
after_locked_quantity: beforeLockedQuantity - quantity,
|
||
batch_no: storageRow.batch_no,
|
||
inventory_type: storageRow.inventory_type,
|
||
order_type: 'PICKING_UNLOCK',
|
||
order_no: 'CANCEL_BATCH',
|
||
order_id: 0,
|
||
operator_id: String(ctx.user?.employees_id ?? ctx.user?.id ?? ''),
|
||
operator_name: ctx.user?.employees_name ?? ctx.user?.real_name ?? ctx.user?.name ?? '',
|
||
remark: '取消分配储位(库存解锁)',
|
||
}, { transaction });
|
||
|
||
storageUnlockSummary.push({
|
||
storage_id: storageId,
|
||
unlocked_quantity: quantity,
|
||
});
|
||
}
|
||
|
||
// fin 记录(已拣货):返还实物数量,锁定已在拣货完成时扣减,不再重复扣除
|
||
for (const [ storageId, returnQuantity ] of finStorageQuantityMap.entries()) {
|
||
if (returnQuantity <= 0) {
|
||
continue;
|
||
}
|
||
|
||
const storageRow = storageMap.get(storageId);
|
||
if (!storageRow) {
|
||
throw new Error(`库存记录不存在: ${storageId}`);
|
||
}
|
||
|
||
const beforeQuantity = toNumber(storageRow.quantity, 0);
|
||
const beforeLockedQuantity = toNumber(storageRow.locked_quantity, 0);
|
||
|
||
await ctx.service.systems.storage.index.updateQuantity(storageId, returnQuantity, 0, {
|
||
transaction,
|
||
});
|
||
|
||
// 写入库存返还流水(实物数量增加,锁定不变)
|
||
await ctx.model.StorageTransaction.create({
|
||
transaction_type: 'INBOUND',
|
||
warehouse_id: warehouseId,
|
||
store_id: storageRow.store_id,
|
||
stock_id: storageRow.stock_id,
|
||
storage_id: storageId,
|
||
space_id: storageRow.space_id,
|
||
quantity: returnQuantity,
|
||
before_quantity: beforeQuantity,
|
||
after_quantity: beforeQuantity + returnQuantity,
|
||
before_locked_quantity: beforeLockedQuantity,
|
||
after_locked_quantity: beforeLockedQuantity,
|
||
batch_no: storageRow.batch_no,
|
||
inventory_type: storageRow.inventory_type,
|
||
order_type: 'PICK_RETURN',
|
||
order_no: 'CANCEL_BATCH',
|
||
order_id: 0,
|
||
operator_id: String(ctx.user?.employees_id ?? ctx.user?.id ?? ''),
|
||
operator_name: ctx.user?.employees_name ?? ctx.user?.real_name ?? ctx.user?.name ?? '',
|
||
remark: '取消分配储位(已拣货返还库存)',
|
||
}, { transaction });
|
||
|
||
storageReturnSummary.push({
|
||
storage_id: storageId,
|
||
returned_quantity: returnQuantity,
|
||
});
|
||
}
|
||
|
||
const cancelPickingIds = [];
|
||
for (const orderId of cancellableOrderIds) {
|
||
const orderPickingRows = pickingRowsByOrderId.get(orderId) || [];
|
||
cancelPickingIds.push(...orderPickingRows.map(row => toNumber(row.id, 0)).filter(pickingId => pickingId > 0));
|
||
}
|
||
|
||
if (cancelPickingIds.length > 0) {
|
||
await pickingModel.destroy({
|
||
where: {
|
||
id: {
|
||
[Op.in]: cancelPickingIds,
|
||
},
|
||
},
|
||
transaction,
|
||
});
|
||
}
|
||
|
||
const cancelOrderWhere = {
|
||
id: {
|
||
[Op.in]: cancellableOrderIds,
|
||
},
|
||
warehouse_id: warehouseId,
|
||
};
|
||
|
||
await orderModel.update({
|
||
storage_status: 'none',
|
||
order_flag: '',
|
||
updated_at: now,
|
||
}, {
|
||
where: cancelOrderWhere,
|
||
transaction,
|
||
});
|
||
|
||
const updatedOrders = await orderModel.findAll({
|
||
where: cancelOrderWhere,
|
||
transaction,
|
||
raw: true,
|
||
});
|
||
|
||
const updatedOrderMap = new Map();
|
||
for (const updatedOrder of Array.isArray(updatedOrders) ? updatedOrders : []) {
|
||
const plainOrder = toPlainRecord(updatedOrder);
|
||
if (!plainOrder || !Number(plainOrder.id)) {
|
||
continue;
|
||
}
|
||
|
||
updatedOrderMap.set(Number(plainOrder.id), plainOrder);
|
||
}
|
||
|
||
const orderResults = cancellableOrderIds
|
||
.map(orderId => updatedOrderMap.get(orderId))
|
||
.filter(Boolean)
|
||
.map(order => ({
|
||
order_id: order.id,
|
||
storage_status: order.storage_status,
|
||
order_flag: order.order_flag || '',
|
||
status: 'success',
|
||
}));
|
||
|
||
const responseData = {
|
||
warehouse_id: warehouseId,
|
||
requested_order_ids: orderIds,
|
||
cancellable_order_ids: cancellableOrderIds,
|
||
skipped_orders: skippedOrders,
|
||
orders: [ ...skippedOrders, ...orderResults ],
|
||
picking_count: cancelPickingIds.length,
|
||
storage_unlock_summary: storageUnlockSummary,
|
||
storage_return_summary: storageReturnSummary,
|
||
stock_unlock_summary: [],
|
||
};
|
||
|
||
await transaction.commit();
|
||
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 事务提交完成', {
|
||
warehouseId,
|
||
requestedOrderIds: orderIds,
|
||
cancellableOrderIds,
|
||
skippedOrders,
|
||
});
|
||
|
||
return {
|
||
code: 200,
|
||
message: '取消分配完成',
|
||
data: responseData,
|
||
};
|
||
} catch (error) {
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 发生异常,准备回滚事务', {
|
||
warehouseId,
|
||
orderIds,
|
||
error,
|
||
});
|
||
await transaction.rollback();
|
||
writeAllocationTextLog('[OrderStorageAllocationService.cancelAllocateStorage] 事务回滚完成', {
|
||
warehouseId,
|
||
orderIds,
|
||
error,
|
||
});
|
||
throw error;
|
||
}
|
||
}
|
||
/**
|
||
* 分拣缺货补货需求计算。
|
||
*
|
||
* 仓库级别的计算,针对当前仓库所有未完成储位分配的订单,
|
||
* 计算每个 SKU 在分拣区与存货区的可用库存对比,
|
||
* 输出分拣区缺口及建议补货量,供仓库人员决策移库。
|
||
*
|
||
* 入参:
|
||
* - `warehouse_id`(可选):仓库 ID,不传则使用当前用户上下文
|
||
*
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 补货需求明细与汇总信息。
|
||
* `list` 每项包含 `is_true_shortage`(两区均无库存时为 true),
|
||
* `summary` 包含 `total_true_shortage_skus`(真正缺货的 SKU 数量)。
|
||
*/
|
||
}
|
||
|
||
module.exports = OrderStorageAllocationService;
|