liufumingren eb100b056d 1
2026-06-07 01:52:06 +08:00

2431 lines
86 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 Service = require('egg').Service;
const DAY_MS = 24 * 60 * 60 * 1000;
/**
* 计算库存批次的保质期预警状态。
*
* @param {Object} stock 商品库存资料
* @param {string|Date|null} expiryDate 批次到期日期
* @param {number} [nowMs=Date.now()] 当前时间戳
* @return {{remainingDays: (number|null), isTriggered: boolean}} 预警信息
*/
function getShelfLifeWarningState(stock = {}, expiryDate = null, nowMs = Date.now()) {
const expiryTime = expiryDate ? new Date(expiryDate).getTime() : null;
const remainingDays = expiryTime === null || Number.isNaN(expiryTime)
? null
: Math.max(0, Math.ceil((expiryTime - nowMs) / DAY_MS));
const isShelfLifeMgmt = stock.is_shelf_life_mgmt === 'Y' || stock.is_shelf_life_mgmt === true;
const thresholdDays = Number(stock.remaining_threshold_days) || 0;
return {
remainingDays,
isTriggered: Boolean(isShelfLifeMgmt && thresholdDays > 0 && remainingDays !== null && remainingDays <= thresholdDays),
};
}
/**
* 将库存预警规则转换为按到期天数递增的区间配置。
*
* @param {Array<Object>} warningRules 库存预警规则
* @return {Array<{name: string, key: string, tip_text: string, min_days: number, max_days: number}>} 规则区间列表
*/
function buildInventoryWarningRanges(warningRules = []) {
if (!Array.isArray(warningRules) || !warningRules.length) {
return [];
}
const sortedRules = warningRules
.filter(rule => rule && typeof rule === 'object')
.map(rule => ({
name: rule.name,
key: rule.key,
tip_text: rule.tip_text === undefined || rule.tip_text === null ? '' : String(rule.tip_text),
expire_days: Number(rule.expire_days),
}))
.filter(rule => Number.isInteger(rule.expire_days) && rule.expire_days >= 0)
.sort((a, b) => a.expire_days - b.expire_days);
let previousMax = null;
return sortedRules.map(rule => {
const minDays = previousMax === null ? 0 : previousMax + 1;
const maxDays = rule.expire_days;
previousMax = maxDays;
return {
name: rule.name,
key: rule.key,
tip_text: rule.tip_text,
min_days: minDays,
max_days: maxDays,
};
});
}
/**
* 根据剩余天数命中库存预警规则并返回响应字段。
*
* @param {number|null} remainingDays 到期剩余天数
* @param {Array<Object>} warningRanges 预警规则区间
* @return {{expiry_remaining_days: (number|null), inventory_warning_level: (string|null), inventory_warning_color: (string|null), inventory_warning_range: ({min_days: number, max_days: number}|null), inventory_warning_tip_text: (string|null)}} 预警输出字段
*/
function getInventoryWarningPayload(remainingDays, warningRanges = []) {
if (!Number.isInteger(remainingDays) || !Array.isArray(warningRanges) || !warningRanges.length) {
return {
expiry_remaining_days: null,
inventory_warning_level: null,
inventory_warning_color: null,
inventory_warning_range: null,
inventory_warning_tip_text: null,
};
}
const matchedRange = warningRanges.find(rule => (
remainingDays >= rule.min_days && remainingDays <= rule.max_days
));
if (!matchedRange) {
return {
expiry_remaining_days: remainingDays,
inventory_warning_level: null,
inventory_warning_color: null,
inventory_warning_range: null,
inventory_warning_tip_text: null,
};
}
return {
expiry_remaining_days: remainingDays,
inventory_warning_level: matchedRange.name || null,
inventory_warning_color: matchedRange.key || null,
inventory_warning_range: {
min_days: matchedRange.min_days,
max_days: matchedRange.max_days,
},
inventory_warning_tip_text: matchedRange.tip_text,
};
}
/**
* 将库存商品上的标记值规范化为布尔值。
*
* @param {unknown} value 待转换的标记值
* @return {boolean} 是否为真值
*/
function toBooleanFlag(value) {
if (typeof value === 'boolean') {
return value;
}
if (typeof value === 'number') {
return value === 1;
}
if (typeof value === 'string') {
return [ 'Y', '1', 'TRUE', 'T', 'YES' ].includes(value.trim().toUpperCase());
}
return false;
}
/**
* 将模型查询结果转换为普通对象。
*
* @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 {Object} ctx 当前请求上下文
* @param {number[]} stockIds 商品ID列表
* @return {Promise<{barcodesByStockId: Map<number, string[]>, imagesByStockId: Map<number, string[]>}>} 附属信息映射
*/
async function loadStockAttachments(ctx, stockIds = []) {
const uniqueStockIds = [ ...new Set(
Array.isArray(stockIds)
? stockIds.map(item => Number(item)).filter(Boolean)
: []
) ];
const barcodesByStockId = new Map();
const imagesByStockId = new Map();
if (!uniqueStockIds.length) {
return { barcodesByStockId, imagesByStockId };
}
const hasStockBarcodeModel = ctx.model && ctx.model.StockBarcode && typeof ctx.model.StockBarcode.findAll === 'function';
if (hasStockBarcodeModel) {
try {
const barcodeRows = await ctx.model.StockBarcode.findAll({
where: {
stock_id: {
[ctx.app.Sequelize.Op.in]: uniqueStockIds,
},
},
attributes: [ 'stock_id', 'barcode' ],
raw: true,
});
for (const item of barcodeRows || []) {
const row = toPlainRecord(item);
if (!row) {
continue;
}
const stockId = Number(row.stock_id);
const barcode = row.barcode ? String(row.barcode) : '';
if (!stockId || !barcode) {
continue;
}
if (!barcodesByStockId.has(stockId)) {
barcodesByStockId.set(stockId, []);
}
barcodesByStockId.get(stockId).push(barcode);
}
} catch (error) {
ctx.logger?.warn?.('[storage.inventory] 查询商品条码失败,已降级为空数组', {
error: error.message,
});
}
}
const hasFileReferenceModel = ctx.model && ctx.model.FileReference && typeof ctx.model.FileReference.findAll === 'function';
const hasFileModel = Boolean(ctx.model && ctx.model.File);
if (hasFileReferenceModel && hasFileModel) {
try {
const imageRows = await ctx.model.FileReference.findAll({
where: {
business_type: 'stock',
business_id: {
[ctx.app.Sequelize.Op.in]: uniqueStockIds,
},
},
include: [{
model: ctx.model.File,
as: 'file',
attributes: [ 'file_url' ],
required: false,
}],
});
for (const item of imageRows || []) {
const row = toPlainRecord(item);
if (!row) {
continue;
}
const stockId = Number(row.business_id);
const imageUrl = (row.file && row.file.file_url) || row.file_url || row.url || row.file_path || '';
if (!stockId || !imageUrl) {
continue;
}
if (!imagesByStockId.has(stockId)) {
imagesByStockId.set(stockId, []);
}
imagesByStockId.get(stockId).push(String(imageUrl));
}
} catch (error) {
ctx.logger?.warn?.('[storage.inventory] 查询商品图片失败,已降级为空数组', {
error: error.message,
});
}
}
return {
barcodesByStockId,
imagesByStockId,
};
}
/**
* 为库存列表补充商品附属信息。
*
* @param {Object} ctx 当前请求上下文
* @param {Object[]} list 库存列表
* @return {Promise<void>}
*/
async function enrichInventoryStockAttachments(ctx, list = []) {
const stockIds = list.map(item => Number(item?.stock?.id || item?.stock_id || 0)).filter(Boolean);
const { barcodesByStockId, imagesByStockId } = await loadStockAttachments(ctx, stockIds);
for (const item of list) {
const stockId = Number(item?.stock?.id || item?.stock_id || 0);
if (!stockId) {
continue;
}
if (!item.stock) {
item.stock = {};
}
item.stock.barcodes = barcodesByStockId.get(stockId) || [];
item.stock.images = imagesByStockId.get(stockId) || [];
}
}
class InventoryService extends Service {
/**
* 收货单快捷入库上架。
* 从收货单直接生成入库单并写入库存。
*
* 流程:
* 1. 校验收货单状态(必须 completed)
* 2. 校验收货单已审核(is_review = 1)
* 3. 校验所有明细已匹配系统商品(system_product_id 不为空)
* 4. 校验未全部入库(storage_status !== 'all')
* 4. 事务内:
* a. 创建入库单(EntryOrder)和入库明细(EntryItems)
* b. 逐条锁定 StockWarehouse 行,增加 quantity
* c. 写入/更新 wms_storage 库存记录
* d. 更新 receiving_detail 的 storage_status 和 stored_quantity
* e. 更新 receiving 的 storage_status
*
* @param {Object} data 请求体
* @param {number} data.receiving_id 收货单ID(必填)
* @return {Promise<Object>} code/data/message 结构
*/
async quickPutaway(data = {}) {
const { ctx, app } = this;
const warehouseId = ctx.user.store_id;
const receivingId = Number(data.receiving_id || data.id || 0);
if (!receivingId) {
return { code: 400, message: 'receiving_id 必填', data: null };
}
const transaction = await ctx.model.transaction();
try {
// ────────── 1. 查询并锁定收货单 ──────────
const receiving = await ctx.model.Receiving.findOne({
where: {
id: receivingId,
warehouse_id: warehouseId,
is_deleted: false,
},
lock: transaction.LOCK.UPDATE,
transaction,
include: [{
model: ctx.model.ReceivingDetail,
as: 'details',
required: false,
}],
});
if (!receiving) {
await transaction.rollback();
return { code: 404, message: '收货单不存在或无权访问', data: null };
}
if (receiving.status !== 'completed') {
await transaction.rollback();
return { code: 400, message: `收货单状态为 ${receiving.status},须完成收货后才能入库`, data: null };
}
if (Number(receiving.is_review) !== 1) {
await transaction.rollback();
return { code: 400, message: '收货单未审核,审核通过后才能入库', data: null };
}
const storeRelation = await ctx.model.StoreWarehouse.findOne({
where: {
warehouse_id: warehouseId,
store_id: Number(receiving.store_id || 0),
use_status: 1,
},
attributes: [ 'id', 'policy_config', 'store_remask' ],
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!storeRelation) {
await transaction.rollback();
return { code: 404, message: '收货单绑定的货主与当前仓库不存在有效签约关系', data: null };
}
const policyConfig = storeRelation.policy_config && typeof storeRelation.policy_config === 'object'
? storeRelation.policy_config
: {};
if (Number(policyConfig.allow_receiving_quick_putaway) !== 1) {
const storeName = String(storeRelation.store_remask || receiving.store_name || receiving.store_id || '当前货主');
await transaction.rollback();
return { code: 400, message: `货主${storeName}不允许快速上架,如需开启请到:货主->策略配置调整`, data: null };
}
if (receiving.storage_status === 'all') {
await transaction.rollback();
return { code: 400, message: '该收货单已全部入库,无需重复操作', data: null };
}
const details = receiving.details || [];
if (!details.length) {
await transaction.rollback();
return { code: 400, message: '收货单没有明细,无法入库', data: null };
}
// ────────── 3. 校验所有明细已匹配系统商品 ──────────
const unmatchedDetails = details.filter(d => !d.system_product_id);
if (unmatchedDetails.length > 0) {
await transaction.rollback();
const names = unmatchedDetails.map(d => d.product_name).join('、');
return {
code: 400,
message: `以下商品未匹配系统商品,请先绑定:${names}`,
data: { unmatched_count: unmatchedDetails.length, unmatched_names: names },
};
}
// 过滤出需要入库的明细(排除已全部入库的)
const pendingDetails = details.filter(d => d.storage_status !== 'all');
if (!pendingDetails.length) {
await transaction.rollback();
return { code: 400, message: '所有明细已入库完成', data: null };
}
// ────────── 4. 创建入库单 ──────────
// 获取仓库名称快照
let warehouseName = '';
const warehouseData = await ctx.service.systems.store.getStoreName(warehouseId);
if (warehouseData.code === 200 && warehouseData.data) {
warehouseName = warehouseData.data.company_name || '';
}
// 获取合约表备注名称(优先使用)
const contract_data = await ctx.service.systems.store.getStoreRemaskName(receiving.store_id, warehouseId);
let contract = null;
if (contract_data.code === 200) {
contract = contract_data.data;
}
const entryOrderCode = `SCRK${Date.now()}${String(Math.floor(Math.random() * 10000)).padStart(4, '0')}`;
const entryOrder = await ctx.model.EntryOrder.create({
entry_order_code: entryOrderCode,
order_type: 'SCRK',
purchase_order_code: receiving.receiving_number || '',
total_order_lines: pendingDetails.length,
order_create_time: new Date(),
source_type: 'WMS',
order_status: 'CREATED',
sync_status: 'SUCCESS',
sync_message: `快捷入库-来自收货单 ${receiving.receiving_number}`,
is_enabled: 1,
warehouse_id: warehouseId,
store_id: receiving.store_id || warehouseId,
store_name: contract?.store_remask || receiving.store_name || '',
warehouse_name: contract?.warehouse_remask || warehouseName,
remark: `快捷入库,关联收货单 ${receiving.receiving_number}`,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
// ────────── 5. 逐条处理明细:创建入库明细 + 更新库存 ──────────
const results = [];
const errors = [];
for (let i = 0; i < pendingDetails.length; i++) {
const detail = pendingDetails[i];
const stockWarehouseId = detail.system_product_id;
const inboundQty = (detail.actual_quantity || 0) - (detail.stored_quantity || 0);
if (inboundQty <= 0) {
continue; // 已入库完的跳过
}
// 5a. 锁定 StockWarehouse 行
const stockRecord = await ctx.model.StockWarehouse.findOne({
where: {
id: stockWarehouseId,
is_valid: 'Y',
deleted_at: null,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!stockRecord) {
errors.push(`商品 ${detail.product_name} 的库存记录不存在 (stock_id: ${stockWarehouseId})`);
continue;
}
// 5b. 增加 StockWarehouse 库存数量
const beforeQuantity = Number(stockRecord.quantity) || 0;
const beforeLockedQuantity = Number(stockRecord.locked_quantity) || 0;
await stockRecord.increment('quantity', {
by: inboundQty,
transaction,
silent: true,
});
await stockRecord.reload({ transaction });
const afterQuantity = Number(stockRecord.quantity) || 0;
const afterLockedQuantity = Number(stockRecord.locked_quantity) || 0;
// 5c. 写入/更新 wms_storage 库存位置表
const spaceId = detail.space_id || 1; // 明细有库位则用,否则默认库位
const batchNo = String(detail.batch_number || '').trim() || String(receiving.receiving_number || '').trim() || entryOrderCode;
const productionDate = detail.production_date || null;
const expiryDate = detail.expiry_date || null;
const inventoryType = 'ZP'; // 默认正品
// 查找是否已有相同 库位+SKU+批次+类型 的库存记录
let storageRecord = await ctx.model.Storage.findOne({
where: {
space_id: spaceId,
stock_id: stockWarehouseId,
batch_no: batchNo,
inventory_type: inventoryType,
is_enabled: 1,
delete_at: null,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (storageRecord) {
// 已有记录:累加数量
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity + ${inboundQty}`),
available_quantity: app.Sequelize.literal(`available_quantity + ${inboundQty}`),
entry_order_id: entryOrder.id,
batch_no: batchNo,
production_date: productionDate,
expiry_date: expiryDate,
updated_at: new Date(),
}, {
where: { id: storageRecord.id },
transaction,
});
} else {
// 新建库存记录
storageRecord = await ctx.model.Storage.create({
warehouse_id: warehouseId,
store_id: receiving.store_id || warehouseId,
space_id: spaceId,
stock_id: stockWarehouseId,
batch_no: batchNo,
inventory_type: inventoryType,
quantity: inboundQty,
locked_quantity: 0,
available_quantity: inboundQty,
production_date: productionDate,
expiry_date: expiryDate,
inbound_time: new Date(),
inbound_order_no: entryOrderCode,
receiving_id: receivingId,
entry_order_id: entryOrder.id,
supplier_id: null,
supplier_batch_no: null,
is_enabled: 1,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
}
// 5d. 创建入库明细
await ctx.model.EntryItems.create({
order_id: entryOrder.id,
order_line_no: i + 1,
item_code: stockRecord.item_code || '',
item_id: stockWarehouseId,
count: inboundQty,
inventory_type: inventoryType,
stock_id: stockWarehouseId,
received_quantity: inboundQty,
confirm_quantity: inboundQty,
}, { transaction });
// 5d+. 写入出入库记录
await ctx.service.systems.stockTransaction.create({
transaction_type: 'INBOUND',
warehouse_id: warehouseId,
store_id: receiving.store_id || warehouseId,
stock_id: stockWarehouseId,
storage_id: storageRecord.id,
space_id: spaceId,
quantity: inboundQty,
batch_no: batchNo,
inventory_type: inventoryType,
order_type: 'SCRK',
order_no: entryOrderCode,
order_id: null,
receiving_id: receivingId,
entry_order_id: entryOrder.id,
operator_id: String(ctx.user?.employees_id || ctx.user?.id || ''),
operator_name: ctx.user?.employees_name || '',
remark: `快捷入库-收货单 ${receiving.receiving_number}`,
before_quantity: beforeQuantity,
after_quantity: afterQuantity,
before_locked_quantity: beforeLockedQuantity,
after_locked_quantity: afterLockedQuantity,
created_at: new Date(),
}, { transaction });
// 5e. 更新收货明细的入库状态
const newStoredQty = (detail.stored_quantity || 0) + inboundQty;
const detailStorageStatus = newStoredQty >= detail.actual_quantity ? 'all' : 'partial';
await ctx.model.ReceivingDetail.update({
storage_status: detailStorageStatus,
stored_quantity: newStoredQty,
}, {
where: { id: detail.id },
transaction,
});
results.push({
detail_id: detail.id,
product_name: detail.product_name,
stock_warehouse_id: stockWarehouseId,
inbound_quantity: inboundQty,
space_id: spaceId,
storage_status: detailStorageStatus,
});
}
// 如果全部明细都失败
if (results.length === 0 && errors.length > 0) {
await transaction.rollback();
return {
code: 400,
message: `入库失败:${errors.join(';')}`,
data: null,
};
}
// ────────── 6. 更新入库单状态 ──────────
await entryOrder.update({
order_status: 'COMPLETED',
total_order_lines: results.length,
updated_at: new Date(),
}, { transaction });
// ────────── 7. 更新收货单入库状态 ──────────
const allDetailsStored = details.every(d => {
if (d.storage_status === 'all') return true;
// 检查本次入库后是否全部完成
const pending = pendingDetails.find(p => p.id === d.id);
if (!pending) return true;
const newStored = (pending.stored_quantity || 0) + ((pending.actual_quantity || 0) - (pending.stored_quantity || 0));
return newStored >= pending.actual_quantity;
});
const receivingStorageStatus = allDetailsStored ? 'all' : 'partial';
await ctx.model.Receiving.update({
storage_status: receivingStorageStatus,
}, {
where: { id: receivingId },
transaction,
});
// ────────── 8. 提交事务 ──────────
await transaction.commit();
// 记录操作日志
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry',
businessId: entryOrder.id,
operationCode: 'QUICK_PUTAWAY',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId,
},
beforeChanges: null,
});
} catch (logErr) {
ctx.logger.warn('[quickPutaway] 写入操作日志失败,不影响业务', logErr);
}
ctx.logger.info('[quickPutaway] 快捷入库完成', {
receiving_id: receivingId,
receiving_number: receiving.receiving_number,
entry_order_code: entryOrderCode,
entry_order_id: entryOrder.id,
total_items: results.length,
errors: errors.length,
});
return {
code: 200,
message: errors.length
? `入库部分完成,${results.length} 条成功,${errors.length} 条失败`
: '快捷入库完成',
data: {
receiving_id: receivingId,
receiving_number: receiving.receiving_number,
receiving_storage_status: receivingStorageStatus,
entry_order: {
id: entryOrder.id,
entry_order_code: entryOrderCode,
order_status: 'COMPLETED',
},
items: results,
errors: errors.length ? errors : undefined,
},
};
} catch (error) {
await transaction.rollback();
ctx.logger.error('[quickPutaway] 快捷入库异常', {
receiving_id: receivingId,
error: error.message,
stack: error.stack,
});
if (error.name === 'SequelizeDatabaseError' && error.message.includes('Lock wait timeout')) {
return {
code: 409,
message: '库存记录被锁定,请稍后重试',
data: null,
};
}
throw error;
}
}
/**
* 匹配入库:将已完成收货的收货单与已有入库单按 stock_warehouse_id 做数量匹配入库。
*
* @param {Object} data 请求体
* @param {number[]} data.receiving_ids 收货单ID列表
* @param {number[]} data.entry_order_ids 入库单ID列表
* @return {Promise<Object>} code/data/message 结构
*/
async matchPutaway(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const warehouseId = ctx.user.store_id;
// ────────── 1. 参数校验 ──────────
const receivingIds = Array.isArray(data.receiving_ids) ? data.receiving_ids.map(Number).filter(Boolean) : [];
const entryOrderIds = Array.isArray(data.entry_order_ids) ? data.entry_order_ids.map(Number).filter(Boolean) : [];
if (!receivingIds.length) {
return { code: 400, message: 'receiving_ids 不能为空', data: null };
}
if (!entryOrderIds.length) {
return { code: 400, message: 'entry_order_ids 不能为空', data: null };
}
// ────────── 2. 开事务 ──────────
const transaction = await ctx.model.transaction();
try {
// ────────── 3. 查询并锁定收货单 ──────────
const receivings = await ctx.model.Receiving.findAll({
where: {
id: { [Op.in]: receivingIds },
warehouse_id: warehouseId,
status: 'completed',
is_deleted: false,
},
lock: transaction.LOCK.UPDATE,
transaction,
include: [{
model: ctx.model.ReceivingDetail,
as: 'details',
required: false,
}],
});
if (!receivings.length) {
await transaction.rollback();
return { code: 404, message: '未找到符合条件的收货单', data: null };
}
const unreviewedReceiving = receivings.find(item => Number(item.is_review) !== 1);
if (unreviewedReceiving) {
await transaction.rollback();
return {
code: 400,
message: `收货单 ${unreviewedReceiving.receiving_number || unreviewedReceiving.id} 未审核,审核通过后才能入库`,
data: null,
};
}
// ────────── 4. 查询并锁定入库单 ──────────
const entryOrders = await ctx.model.EntryOrder.findAll({
where: {
id: { [Op.in]: entryOrderIds },
warehouse_id: warehouseId,
is_enabled: 1,
deleted_at: null,
order_status: { [Op.in]: [ 'PENDING', 'CONFIRMED', 'PARTIAL_RECEIVED', 'CREATED' ] },
},
lock: transaction.LOCK.UPDATE,
transaction,
include: [{
model: ctx.model.EntryItems,
as: 'items',
required: false,
}],
});
if (!entryOrders.length) {
await transaction.rollback();
return { code: 404, message: '未找到符合条件的入库单', data: null };
}
// ────────── 5. 按 stock_warehouse_id 汇总 ──────────
// 收货侧:可入库明细(排除已全部入库的)
const rcvDetailsBySWId = {}; // stock_warehouse_id -> [ detail, ... ]
for (const rcv of receivings) {
for (const d of (rcv.details || [])) {
if (d.storage_status === 'all') continue;
if (!d.system_product_id) continue;
const available = (d.actual_quantity || 0) - (d.stored_quantity || 0);
if (available <= 0) continue;
const key = d.system_product_id;
if (!rcvDetailsBySWId[key]) rcvDetailsBySWId[key] = [];
rcvDetailsBySWId[key].push({ detail: d, available, receiving: rcv });
}
}
// 入库侧:待入库明细
const entryItemsBySWId = {}; // stock_warehouse_id -> [ item, ... ]
for (const eo of entryOrders) {
for (const item of (eo.items || [])) {
if (!item.stock_id) continue;
const remaining = (item.count || 0) - (item.received_quantity || 0);
if (remaining <= 0) continue;
const key = item.stock_id;
if (!entryItemsBySWId[key]) entryItemsBySWId[key] = [];
entryItemsBySWId[key].push({ item, remaining, entryOrder: eo });
}
}
// ────────── 6. 逐个 stock_warehouse_id 执行匹配 ──────────
const matchedItems = [];
const unmatchedProducts = [];
const warnings = [];
// 跟踪各明细的累计分配量
const rcvDetailAllocated = {}; // detail.id -> allocated qty
const entryItemAllocated = {}; // item.id -> allocated qty
// 取交集 key
const allSWIds = new Set([
...Object.keys(rcvDetailsBySWId),
...Object.keys(entryItemsBySWId),
]);
for (const swIdStr of allSWIds) {
const swId = Number(swIdStr);
const rcvGroup = rcvDetailsBySWId[swId];
const entryGroup = entryItemsBySWId[swId];
if (!rcvGroup || !entryGroup) {
if (rcvGroup && !entryGroup) {
unmatchedProducts.push({ stock_warehouse_id: swId, reason: '收货侧有库存但无对应入库计划' });
}
if (!rcvGroup && entryGroup) {
unmatchedProducts.push({ stock_warehouse_id: swId, reason: '入库计划存在但无对应收货明细' });
}
continue;
}
// 计算总量
const totalRcvAvailable = rcvGroup.reduce((s, r) => s + r.available, 0);
const totalEntryRemaining = entryGroup.reduce((s, e) => s + e.remaining, 0);
const actualInbound = Math.min(totalRcvAvailable, totalEntryRemaining);
if (actualInbound <= 0) continue;
if (totalRcvAvailable < totalEntryRemaining) {
warnings.push(
`stock_warehouse_id=${swId}: 收货可入库量(${totalRcvAvailable}) < 入库计划量(${totalEntryRemaining}),按收货量入库`
);
}
// 6a. 锁定 stock_warehouse 行并增加 quantity
const stockRecord = await ctx.model.StockWarehouse.findOne({
where: { id: swId, is_valid: 'Y', deleted_at: null },
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!stockRecord) {
warnings.push(`stock_warehouse_id=${swId}: 库存记录不存在,跳过`);
continue;
}
const beforeQuantity = Number(stockRecord.quantity) || 0;
const beforeLockedQuantity = Number(stockRecord.locked_quantity) || 0;
await stockRecord.increment('quantity', {
by: actualInbound,
transaction,
silent: true,
});
await stockRecord.reload({ transaction });
const afterQuantity = Number(stockRecord.quantity) || 0;
const afterLockedQuantity = Number(stockRecord.locked_quantity) || 0;
// 6b. 写入/更新 wms_storage(取第一个收货明细的信息)
const firstRcvDetail = rcvGroup[0].detail;
const firstRcv = rcvGroup[0].receiving;
const firstEntryOrder = entryGroup[0].entryOrder;
const spaceId = firstRcvDetail.space_id || 1;
const batchNo = firstRcvDetail.batch_number || firstRcv.receiving_number || '';
const inventoryType = 'ZP';
let storageRecord = await ctx.model.Storage.findOne({
where: {
space_id: spaceId,
stock_id: swId,
batch_no: batchNo,
inventory_type: inventoryType,
is_enabled: 1,
delete_at: null,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (storageRecord) {
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity + ${actualInbound}`),
available_quantity: app.Sequelize.literal(`available_quantity + ${actualInbound}`),
entry_order_id: firstEntryOrder.id,
}, {
where: { id: storageRecord.id },
transaction,
});
} else {
storageRecord = await ctx.model.Storage.create({
warehouse_id: warehouseId,
store_id: firstRcv.store_id || warehouseId,
space_id: spaceId,
stock_id: swId,
batch_no: batchNo,
inventory_type: inventoryType,
quantity: actualInbound,
locked_quantity: 0,
available_quantity: actualInbound,
production_date: firstRcvDetail.production_date || null,
expiry_date: firstRcvDetail.expiry_date || null,
inbound_time: new Date(),
inbound_order_no: firstEntryOrder.entry_order_code,
receiving_id: firstRcv.id,
entry_order_id: firstEntryOrder.id,
supplier_id: null,
supplier_batch_no: null,
is_enabled: 1,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
}
// 6b+. 写入出入库记录
await ctx.service.systems.stockTransaction.create({
transaction_type: 'INBOUND',
warehouse_id: warehouseId,
store_id: firstRcv.store_id || warehouseId,
stock_id: swId,
storage_id: storageRecord.id,
space_id: spaceId,
quantity: actualInbound,
batch_no: batchNo,
inventory_type: inventoryType,
order_type: 'MATCH',
order_no: firstEntryOrder.entry_order_code,
order_id: null,
receiving_id: firstRcv.id,
entry_order_id: firstEntryOrder.id,
operator_id: String(ctx.user?.employees_id || ctx.user?.id || ''),
operator_name: ctx.user?.employees_name || '',
remark: '匹配入库',
before_quantity: beforeQuantity,
after_quantity: afterQuantity,
before_locked_quantity: beforeLockedQuantity,
after_locked_quantity: afterLockedQuantity,
created_at: new Date(),
}, { transaction });
// 6c. 分配到各个收货明细(按顺序依次扣减)
let rcvRemain = actualInbound;
for (const rcvItem of rcvGroup) {
if (rcvRemain <= 0) break;
const allocate = Math.min(rcvRemain, rcvItem.available);
rcvDetailAllocated[rcvItem.detail.id] = (rcvDetailAllocated[rcvItem.detail.id] || 0) + allocate;
rcvRemain -= allocate;
}
// 6d. 分配到各个入库明细(按顺序依次填充)
let entryRemain = actualInbound;
for (const entryItem of entryGroup) {
if (entryRemain <= 0) break;
const allocate = Math.min(entryRemain, entryItem.remaining);
entryItemAllocated[entryItem.item.id] = (entryItemAllocated[entryItem.item.id] || 0) + allocate;
entryRemain -= allocate;
}
matchedItems.push({
stock_warehouse_id: swId,
item_code: stockRecord.item_code || '',
inbound_quantity: actualInbound,
rcv_available: totalRcvAvailable,
entry_planned: totalEntryRemaining,
});
}
if (!matchedItems.length) {
await transaction.rollback();
return {
code: 400,
message: '没有可匹配入库的商品',
data: { unmatched_products: unmatchedProducts },
};
}
// ────────── 7. 更新收货明细 stored_quantity 和 storage_status ──────────
for (const rcv of receivings) {
for (const d of (rcv.details || [])) {
const allocated = rcvDetailAllocated[d.id];
if (!allocated) continue;
const newStoredQty = (d.stored_quantity || 0) + allocated;
const detailStorageStatus = newStoredQty >= d.actual_quantity ? 'all' : 'partial';
await ctx.model.ReceivingDetail.update({
stored_quantity: newStoredQty,
storage_status: detailStorageStatus,
}, {
where: { id: d.id },
transaction,
});
}
}
// ────────── 8. 更新入库明细 received_quantity ──────────
for (const eo of entryOrders) {
for (const item of (eo.items || [])) {
const allocated = entryItemAllocated[item.id];
if (!allocated) continue;
const newReceivedQty = (item.received_quantity || 0) + allocated;
await ctx.model.EntryItems.update({
received_quantity: newReceivedQty,
}, {
where: { id: item.id },
transaction,
});
}
}
// ────────── 9. 更新收货单 storage_status ──────────
const receivingResults = [];
for (const rcv of receivings) {
const details = rcv.details || [];
const allStored = details.every(d => {
const allocated = rcvDetailAllocated[d.id] || 0;
const newStored = (d.stored_quantity || 0) + allocated;
return d.storage_status === 'all' || newStored >= d.actual_quantity;
});
const hasAny = details.some(d => {
const allocated = rcvDetailAllocated[d.id] || 0;
return d.storage_status !== 'none' || allocated > 0;
});
const newStatus = allStored ? 'all' : (hasAny ? 'partial' : rcv.storage_status);
if (newStatus !== rcv.storage_status) {
await ctx.model.Receiving.update({ storage_status: newStatus }, {
where: { id: rcv.id },
transaction,
});
}
receivingResults.push({
receiving_id: rcv.id,
receiving_number: rcv.receiving_number,
storage_status: newStatus,
});
}
// ────────── 10. 更新入库单 order_status ──────────
const entryOrderResults = [];
const completedEntryOrders = []; // 事务外回传用
for (const eo of entryOrders) {
const items = eo.items || [];
const allFulfilled = items.every(item => {
const allocated = entryItemAllocated[item.id] || 0;
const newReceived = (item.received_quantity || 0) + allocated;
return newReceived >= (item.count || 0);
});
const hasAnyReceived = items.some(item => {
const allocated = entryItemAllocated[item.id] || 0;
return (item.received_quantity || 0) + allocated > 0;
});
let newStatus = eo.order_status;
if (allFulfilled) {
newStatus = 'COMPLETED';
} else if (hasAnyReceived) {
newStatus = 'PARTIAL_RECEIVED';
}
if (newStatus !== eo.order_status) {
await ctx.model.EntryOrder.update({
order_status: newStatus,
updated_at: new Date(),
}, {
where: { id: eo.id },
transaction,
});
}
const result = {
entry_order_id: eo.id,
entry_order_code: eo.entry_order_code,
order_status: newStatus,
source_type: eo.source_type,
callback_status: null,
};
entryOrderResults.push(result);
if (allFulfilled) {
completedEntryOrders.push({ entryOrder: eo, result });
} else {
warnings.push(
`入库单 ${eo.entry_order_code}: 未全部入库完成(${newStatus}),不触发回传,需手工操作或等待其他收货入库`
);
}
}
// ────────── 12. 提交事务 ──────────
await transaction.commit();
// ────────── 13. 事务外:对已完成的入库单触发回传 ──────────
for (const { entryOrder, result } of completedEntryOrders) {
try {
if (entryOrder.source_type === 'QM') {
const confirmResult = await ctx.service.systems.entryOrder.entryorderConfirm(entryOrder.id, true);
result.callback_status = confirmResult.success ? 'SUCCESS' : 'FAILED';
result.callback_detail = confirmResult;
} else if (entryOrder.source_type === 'API') {
const callbackResult = await this.apiCallback(entryOrder);
result.callback_status = callbackResult.success ? 'SUCCESS' : (callbackResult.skipped ? 'SKIPPED' : 'FAILED');
result.callback_detail = callbackResult;
} else {
result.callback_status = 'NOT_REQUIRED';
}
} catch (cbErr) {
ctx.logger.error(`[matchPutaway] 入库单 ${entryOrder.entry_order_code} 回传异常`, cbErr);
result.callback_status = 'ERROR';
result.callback_detail = { error: cbErr.message };
}
}
// ────────── 14. 记录操作日志 ──────────
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry',
businessId: entryOrderIds.join(','),
operationCode: 'MATCH_PUTAWAY',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
extras: { warehouseId, receivingIds, entryOrderIds },
beforeChanges: null,
});
} catch (logErr) {
ctx.logger.warn('[matchPutaway] 写入操作日志失败,不影响业务', logErr);
}
ctx.logger.info('[matchPutaway] 匹配入库完成', {
receiving_ids: receivingIds,
entry_order_ids: entryOrderIds,
matched_count: matchedItems.length,
unmatched_count: unmatchedProducts.length,
warnings_count: warnings.length,
});
// ────────── 15. 返回结果 ──────────
return {
code: 200,
message: '匹配入库完成',
data: {
matched_items: matchedItems,
receiving_results: receivingResults,
entry_order_results: entryOrderResults,
unmatched_products: unmatchedProducts,
warnings: warnings.length ? warnings : undefined,
},
};
} catch (error) {
await transaction.rollback();
ctx.logger.error('[matchPutaway] 匹配入库异常', {
receiving_ids: receivingIds,
entry_order_ids: entryOrderIds,
error: error.message,
stack: error.stack,
});
if (error.name === 'SequelizeDatabaseError' && error.message.includes('Lock wait timeout')) {
return { code: 409, message: '库存记录被锁定,请稍后重试', data: null };
}
throw error;
}
}
/**
* 写入移库双向库位流水(移库出/移库入)。
*
* 说明:
* 1) before/after 与锁定字段均写同值快照,避免被识别为普通出入库数量变化;
* 2) 仅记录移库行为本身,不绑定订单字段。
*
* @param {Object} data 入参
* @param {Object} data.transaction 数据库事务
* @param {Object} data.srcRecord 源库存记录
* @param {number} data.transferQuantity 移库数量
* @param {number} data.sourceSpaceId 源库位ID
* @param {number} data.targetSpaceId 目标库位ID
* @param {number|null} data.targetStorageId 目标库存记录ID
* @param {number} data.totalSnapshotQuantity stock_id 总库存快照数量
* @param {number} data.totalSnapshotLockedQuantity stock_id 总锁定快照数量
* @return {Promise<void>} 无返回值
*/
async createTransferStockTransactions(data = {}) {
const { ctx } = this;
const operatorId = ctx.user?.employees_id || ctx.user?.id || null;
const operatorName = ctx.user?.employees_name || '';
const totalSnapshotQuantity = Number(data.totalSnapshotQuantity) || 0;
const totalSnapshotLockedQuantity = Number(data.totalSnapshotLockedQuantity) || 0;
await ctx.model.StorageTransaction.create({
transaction_type: 'TRANSFER_OUT',
warehouse_id: data.srcRecord.warehouse_id,
store_id: data.srcRecord.store_id,
stock_id: data.srcRecord.stock_id,
storage_id: data.srcRecord.id,
space_id: data.sourceSpaceId,
quantity: data.transferQuantity,
batch_no: data.srcRecord.batch_no,
inventory_type: data.srcRecord.inventory_type,
order_type: null,
order_no: null,
order_id: null,
operator_id: operatorId,
operator_name: operatorName,
remark: '移库出',
before_quantity: totalSnapshotQuantity,
after_quantity: totalSnapshotQuantity,
before_locked_quantity: totalSnapshotLockedQuantity,
after_locked_quantity: totalSnapshotLockedQuantity,
source_order_codes: null,
created_at: new Date(),
}, {
transaction: data.transaction,
});
await ctx.model.StorageTransaction.create({
transaction_type: 'TRANSFER_IN',
warehouse_id: data.srcRecord.warehouse_id,
store_id: data.srcRecord.store_id,
stock_id: data.srcRecord.stock_id,
storage_id: data.targetStorageId,
space_id: data.targetSpaceId,
quantity: data.transferQuantity,
batch_no: data.srcRecord.batch_no,
inventory_type: data.srcRecord.inventory_type,
order_type: null,
order_no: null,
order_id: null,
operator_id: operatorId,
operator_name: operatorName,
remark: '移库入',
before_quantity: totalSnapshotQuantity,
after_quantity: totalSnapshotQuantity,
before_locked_quantity: totalSnapshotLockedQuantity,
after_locked_quantity: totalSnapshotLockedQuantity,
source_order_codes: null,
created_at: new Date(),
}, {
transaction: data.transaction,
});
}
/**
* 移库(库位转移):将单条库存从一个库位移动到另一个库位。
* 支持部分/全量移库、目标库位合并。
*
* @param {Object} data 请求体
* @param {number} data.storage_id 库存记录ID(必填)
* @param {number} data.target_space_id 目标库位ID(必填)
* @param {number} [data.quantity] 移库数量(可选,默认全部移动)
* @return {Promise<Object>} code/data/message 结构
*/
async transferLocation(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
// ────────── 1. 参数校验 ──────────
const storageId = Number(data.storage_id || 0);
if (!storageId) {
return { code: 400, message: 'storage_id 必填', data: null };
}
const targetSpaceId = Number(data.target_space_id || 0);
if (!targetSpaceId) {
return { code: 400, message: 'target_space_id 必填', data: null };
}
if (data.quantity !== undefined && data.quantity !== null) {
const qty = Number(data.quantity);
if (!Number.isFinite(qty) || qty <= 0) {
return { code: 400, message: 'quantity 必须为正数', data: null };
}
}
// ────────── 2. 开事务 ──────────
const transaction = await ctx.model.transaction();
try {
// ────────── 3. 锁定并校验原库存记录 ──────────
const srcRecord = await ctx.model.Storage.findOne({
where: {
id: storageId,
is_enabled: 1,
delete_at: null,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!srcRecord) {
await transaction.rollback();
return { code: 404, message: `库存记录不存在: storage_id=${storageId}`, data: null };
}
const warehouseId = srcRecord.warehouse_id;
const stockWarehouseSnapshot = await ctx.model.StockWarehouse.findOne({
where: { id: srcRecord.stock_id },
attributes: [ 'id', 'quantity', 'locked_quantity' ],
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!stockWarehouseSnapshot) {
await transaction.rollback();
return { code: 404, message: `商品SKU不存在: stock_id=${srcRecord.stock_id}`, data: null };
}
// ────────── 4. 校验目标库位 ──────────
const targetSpace = await ctx.model.LocationSpace.findOne({
where: {
id: targetSpaceId,
is_enabled: true,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!targetSpace) {
await transaction.rollback();
return { code: 404, message: `目标库位不存在或未启用: space_id=${targetSpaceId}`, data: null };
}
if (targetSpace.warehouse_id !== warehouseId) {
await transaction.rollback();
return { code: 400, message: `目标库位 ${targetSpaceId} 不属于仓库 ${warehouseId}`, data: null };
}
if (![ 'AVAILABLE', 'OCCUPIED' ].includes(targetSpace.space_status)) {
await transaction.rollback();
return {
code: 400,
message: `目标库位 ${targetSpace.space_code} 状态为 ${targetSpace.space_status},不可移入`,
data: null,
};
}
// ────────── 5. 处理移库 ──────────
const availableQty = srcRecord.quantity - srcRecord.locked_quantity;
const transferQty = (data.quantity !== undefined && data.quantity !== null)
? Number(data.quantity)
: availableQty;
// 校验移库数量
if (transferQty > availableQty) {
await transaction.rollback();
return {
code: 400,
message: `库存记录 ${storageId} 可用数量不足:可用 ${availableQty},请求移库 ${transferQty}`,
data: null,
};
}
// 原库位与目标库位相同则直接返回
if (srcRecord.space_id === targetSpaceId) {
await transaction.rollback();
return {
code: 200,
message: '原库位与目标库位相同,无需移库',
data: {
storage_id: storageId,
target_space_id: targetSpaceId,
transfer_quantity: 0,
status: 'skipped',
},
};
}
const beforeSnapshot = {
storage_id: storageId,
space_id: srcRecord.space_id,
quantity: srcRecord.quantity,
available_quantity: srcRecord.available_quantity,
};
const isFullTransfer = (transferQty === srcRecord.quantity);
// 查找目标库位是否已有相同 stock_id + batch_no + inventory_type 的记录
const existingTarget = await ctx.model.Storage.findOne({
where: {
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
batch_no: srcRecord.batch_no,
inventory_type: srcRecord.inventory_type,
is_enabled: 1,
delete_at: null,
id: { [Op.ne]: storageId }, // 排除自身(全量移库时直接改 space_id 的情况)
},
lock: transaction.LOCK.UPDATE,
transaction,
});
let afterSnapshot;
let targetStorageId = null;
// 原库位统计变化
const srcSpaceDelta = { skuDelta: 0, qtyDelta: 0 };
// 目标库位统计变化
const tgtSpaceDelta = { skuDelta: 0, qtyDelta: 0 };
if (existingTarget) {
// ── 目标库位已有同规格记录:合并数量 ──
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity + ${transferQty}`),
available_quantity: app.Sequelize.literal(`available_quantity + ${transferQty}`),
updated_at: new Date(),
}, {
where: { id: existingTarget.id },
transaction,
});
if (isFullTransfer) {
// 全量移库且合并:删除原记录
await ctx.model.Storage.update({
is_enabled: 0,
delete_at: new Date(),
updated_at: new Date(),
}, {
where: { id: storageId },
transaction,
});
srcSpaceDelta.qtyDelta -= srcRecord.quantity;
// 检查原库位该 SKU 是否还有其他记录
const remainingSku = await ctx.model.Storage.count({
where: {
space_id: srcRecord.space_id,
stock_id: srcRecord.stock_id,
is_enabled: 1,
delete_at: null,
id: { [Op.ne]: storageId },
},
transaction,
});
if (remainingSku === 0) {
srcSpaceDelta.skuDelta -= 1;
}
} else {
// 部分移库:减少原记录数量
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity - ${transferQty}`),
available_quantity: app.Sequelize.literal(`available_quantity - ${transferQty}`),
updated_at: new Date(),
}, {
where: { id: storageId },
transaction,
});
srcSpaceDelta.qtyDelta -= transferQty;
}
// 目标库位数量增加
tgtSpaceDelta.qtyDelta += transferQty;
// 目标库位该 SKU 之前已有记录,skuDelta 不变
targetStorageId = existingTarget.id;
afterSnapshot = {
merged_into: existingTarget.id,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
source_deleted: isFullTransfer,
};
} else if (isFullTransfer) {
// ── 全量移库 & 目标无同规格记录:直接修改 space_id ──
await ctx.model.Storage.update({
space_id: targetSpaceId,
updated_at: new Date(),
}, {
where: { id: storageId },
transaction,
});
srcSpaceDelta.qtyDelta -= srcRecord.quantity;
// 检查原库位该 SKU 是否还有其他记录
const remainingSku = await ctx.model.Storage.count({
where: {
space_id: srcRecord.space_id,
stock_id: srcRecord.stock_id,
is_enabled: 1,
delete_at: null,
id: { [Op.ne]: storageId },
},
transaction,
});
if (remainingSku === 0) {
srcSpaceDelta.skuDelta -= 1;
}
// 目标库位新增一个 SKU
const existingSkuInTarget = await ctx.model.Storage.count({
where: {
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
is_enabled: 1,
delete_at: null,
id: { [Op.ne]: storageId }, // 排掉自身(此时 space_id 已更新,但事务内逻辑用旧值)
},
transaction,
});
if (existingSkuInTarget === 0) {
tgtSpaceDelta.skuDelta += 1;
}
tgtSpaceDelta.qtyDelta += srcRecord.quantity;
targetStorageId = storageId;
afterSnapshot = {
storage_id: storageId,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
source_deleted: false,
};
} else {
// ── 部分移库 & 目标无同规格记录:减少原记录数量,新建目标记录 ──
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity - ${transferQty}`),
available_quantity: app.Sequelize.literal(`available_quantity - ${transferQty}`),
updated_at: new Date(),
}, {
where: { id: storageId },
transaction,
});
const newRecord = await ctx.model.Storage.create({
warehouse_id: srcRecord.warehouse_id,
store_id: srcRecord.store_id,
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
batch_no: srcRecord.batch_no,
inventory_type: srcRecord.inventory_type,
quantity: transferQty,
locked_quantity: 0,
available_quantity: transferQty,
production_date: srcRecord.production_date,
expiry_date: srcRecord.expiry_date,
inbound_time: srcRecord.inbound_time,
inbound_order_no: srcRecord.inbound_order_no,
receiving_id: srcRecord.receiving_id,
entry_order_id: srcRecord.entry_order_id,
supplier_id: srcRecord.supplier_id,
supplier_batch_no: srcRecord.supplier_batch_no,
is_enabled: 1,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
srcSpaceDelta.qtyDelta -= transferQty;
// 原库位 SKU 数不变(原记录仍在)
// 目标库位:新增 SKU
const existingSkuInTarget = await ctx.model.Storage.count({
where: {
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
is_enabled: 1,
delete_at: null,
},
transaction,
});
// count 包含刚 create 的记录,如果只有 1 条说明之前没有
if (existingSkuInTarget <= 1) {
tgtSpaceDelta.skuDelta += 1;
}
tgtSpaceDelta.qtyDelta += transferQty;
targetStorageId = newRecord.id;
afterSnapshot = {
new_storage_id: newRecord.id,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
source_deleted: false,
};
}
await this.createTransferStockTransactions({
transaction,
srcRecord,
transferQuantity: transferQty,
sourceSpaceId: srcRecord.space_id,
targetSpaceId,
targetStorageId,
totalSnapshotQuantity: Number(stockWarehouseSnapshot.quantity) || 0,
totalSnapshotLockedQuantity: Number(stockWarehouseSnapshot.locked_quantity) || 0,
});
// ────────── 记录操作日志(事务内) ──────────
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'storage',
businessId: storageId,
operationCode: 'STORAGE_TRANSFER_LOCATION',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
},
beforeChanges: beforeSnapshot,
afterChanges: afterSnapshot,
});
} catch (logErr) {
ctx.logger.warn('[inventory.transferLocation] 写入操作日志失败,不影响业务', logErr);
}
// ────────── 6. 更新库位统计 ──────────
const updateSpaceStats = async (spaceId, delta) => {
if (delta.qtyDelta === 0 && delta.skuDelta === 0) return;
const updateFields = {};
if (delta.qtyDelta !== 0) {
updateFields.current_quantity = app.Sequelize.literal(
`GREATEST(COALESCE(current_quantity, 0) + (${delta.qtyDelta}), 0)`
);
}
if (delta.skuDelta !== 0) {
updateFields.current_sku_count = app.Sequelize.literal(
`GREATEST(COALESCE(current_sku_count, 0) + (${delta.skuDelta}), 0)`
);
}
await ctx.model.LocationSpace.update(updateFields, {
where: { id: spaceId },
transaction,
});
};
await updateSpaceStats(srcRecord.space_id, srcSpaceDelta);
await updateSpaceStats(targetSpaceId, tgtSpaceDelta);
// ────────── 7. 提交事务 ──────────
await transaction.commit();
// ────────── 8. 发送通知(事务外) ──────────
try {
await ctx.service.systems.notice.send({
event: 'storage_transfer_completed',
businessName: 'storage',
warehouseId,
subjectId: warehouseId,
title: '移库操作完成',
content: `移库完成:库存${storageId} -> 库位${targetSpaceId}(数量:${transferQty})`,
data: { warehouse_id: warehouseId, storage_id: storageId, target_space_id: targetSpaceId, transfer_quantity: transferQty },
sender: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
});
} catch (noticeErr) {
ctx.logger.warn('[inventory.transferLocation] 发送通知失败,不影响业务', noticeErr);
}
ctx.logger.info('[inventory.transferLocation] 移库完成', {
warehouse_id: warehouseId,
storage_id: storageId,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
});
return {
code: 200,
message: '移库完成',
data: {
storage_id: storageId,
stock_id: srcRecord.stock_id,
target_space_id: targetSpaceId,
transfer_quantity: transferQty,
status: 'success',
},
};
} catch (error) {
await transaction.rollback();
ctx.logger.error('[inventory.transferLocation] 移库异常', {
storage_id: storageId,
target_space_id: targetSpaceId,
error: error.message,
stack: error.stack,
});
if (error.name === 'SequelizeDatabaseError' && error.message.includes('Lock wait timeout')) {
return { code: 409, message: '库存记录被锁定,请稍后重试', data: null };
}
throw error;
}
}
/**
* 按库位+商品维度移库。
* 自动查找该库位下该商品的所有 storage 记录,按 quantity ASC 逐条扣减并合并移动到目标库位。
*
* @param {Object} data 请求体
* @param {number} data.space_id 原库位ID(必填)
* @param {number} data.stock_id 商品SKU ID(必填,对应 wms_stock_warehouse.id)
* @param {number} data.target_space_id 目标库位ID(必填)
* @param {number} data.quantity 移库数量(必填)
* @return {Promise<Object>} code/data/message 结构
*/
async transferByProduct(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
// ────────── 1. 参数校验 ──────────
const spaceId = Number(data.space_id || 0);
const stockId = Number(data.stock_id || 0);
const targetSpaceId = Number(data.target_space_id || 0);
const quantity = Number(data.quantity || 0);
if (!spaceId) {
return { code: 400, message: 'space_id 必填', data: null };
}
if (!stockId) {
return { code: 400, message: 'stock_id 必填', data: null };
}
if (!targetSpaceId) {
return { code: 400, message: 'target_space_id 必填', data: null };
}
if (!Number.isFinite(quantity) || quantity <= 0) {
return { code: 400, message: 'quantity 必须为正数', data: null };
}
// ────────── 2. 批次管理校验 ──────────
const stockWarehouse = await ctx.model.StockWarehouse.findOne({
where: { id: stockId },
attributes: [ 'id', 'is_batch_mgmt' ],
});
if (!stockWarehouse) {
return { code: 404, message: `商品SKU不存在: stock_id=${stockId}`, data: null };
}
if (stockWarehouse.is_batch_mgmt === 'Y') {
return {
code: 400,
message: '该商品已开启批次管理,请使用按库存记录移库(transferLocation)',
data: null,
};
}
// ────────── 3. 原库位与目标库位相同 ──────────
if (spaceId === targetSpaceId) {
return {
code: 200,
message: '原库位与目标库位相同,无需移库',
data: {
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
transfer_quantity: 0,
affected_storage_count: 0,
status: 'skipped',
},
};
}
// ────────── 4. 开事务 ──────────
const transaction = await ctx.model.transaction();
try {
// ────────── 5. 查找并锁定原库存记录 ──────────
const srcRecords = await ctx.model.Storage.findAll({
where: {
space_id: spaceId,
stock_id: stockId,
is_enabled: 1,
delete_at: null,
},
order: [[ 'quantity', 'ASC' ]],
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!srcRecords.length) {
await transaction.rollback();
return { code: 404, message: `原库位 ${spaceId} 下未找到商品 ${stockId} 的库存记录`, data: null };
}
const totalAvailable = srcRecords.reduce((sum, r) => sum + (r.quantity - r.locked_quantity), 0);
if (quantity > totalAvailable) {
await transaction.rollback();
return {
code: 400,
message: `可用数量不足:可用 ${totalAvailable},请求移库 ${quantity}`,
data: null,
};
}
const warehouseId = srcRecords[0].warehouse_id;
const stockWarehouseSnapshot = await ctx.model.StockWarehouse.findOne({
where: { id: stockId },
attributes: [ 'id', 'quantity', 'locked_quantity' ],
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!stockWarehouseSnapshot) {
await transaction.rollback();
return { code: 404, message: `商品SKU不存在: stock_id=${stockId}`, data: null };
}
// ────────── 6. 校验目标库位 ──────────
const targetSpace = await ctx.model.LocationSpace.findOne({
where: {
id: targetSpaceId,
is_enabled: true,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (!targetSpace) {
await transaction.rollback();
return { code: 404, message: `目标库位不存在或未启用: space_id=${targetSpaceId}`, data: null };
}
if (targetSpace.warehouse_id !== warehouseId) {
await transaction.rollback();
return { code: 400, message: `目标库位 ${targetSpaceId} 不属于仓库 ${warehouseId}`, data: null };
}
if (![ 'AVAILABLE', 'OCCUPIED' ].includes(targetSpace.space_status)) {
await transaction.rollback();
return {
code: 400,
message: `目标库位 ${targetSpace.space_code} 状态为 ${targetSpace.space_status},不可移入`,
data: null,
};
}
// ────────── 7. 逐条扣减并移库 ──────────
let remainingQty = quantity;
let affectedCount = 0;
const srcSpaceDelta = { skuDelta: 0, qtyDelta: 0 };
const tgtSpaceDelta = { skuDelta: 0, qtyDelta: 0 };
// 预先记录目标库位是否已有该 SKU(用于事后计算 skuDelta)
const tgtSkuCountBefore = await ctx.model.Storage.count({
where: {
space_id: targetSpaceId,
stock_id: stockId,
is_enabled: 1,
delete_at: null,
},
transaction,
});
for (const srcRecord of srcRecords) {
if (remainingQty <= 0) break;
const available = srcRecord.quantity - srcRecord.locked_quantity;
const toTransfer = Math.min(available, remainingQty);
if (toTransfer <= 0) continue;
affectedCount++;
const isFullTransfer = (toTransfer === srcRecord.quantity);
let targetStorageId = null;
// ── 在目标库位查找同 stock_id + batch_no + inventory_type 的记录 ──
const existingTarget = await ctx.model.Storage.findOne({
where: {
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
batch_no: srcRecord.batch_no,
inventory_type: srcRecord.inventory_type,
is_enabled: 1,
delete_at: null,
id: { [Op.ne]: srcRecord.id },
},
lock: transaction.LOCK.UPDATE,
transaction,
});
if (existingTarget) {
// 目标已有同规格记录:合并数量
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity + ${toTransfer}`),
available_quantity: app.Sequelize.literal(`available_quantity + ${toTransfer}`),
updated_at: new Date(),
}, {
where: { id: existingTarget.id },
transaction,
});
if (isFullTransfer) {
// 全量:软删除原记录
await ctx.model.Storage.update({
is_enabled: 0,
delete_at: new Date(),
updated_at: new Date(),
}, {
where: { id: srcRecord.id },
transaction,
});
} else {
// 部分:减少原记录
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity - ${toTransfer}`),
available_quantity: app.Sequelize.literal(`available_quantity - ${toTransfer}`),
updated_at: new Date(),
}, {
where: { id: srcRecord.id },
transaction,
});
}
targetStorageId = existingTarget.id;
} else if (isFullTransfer) {
// 全量移库 & 目标无同规格记录:直接改 space_id
await ctx.model.Storage.update({
space_id: targetSpaceId,
updated_at: new Date(),
}, {
where: { id: srcRecord.id },
transaction,
});
targetStorageId = srcRecord.id;
} else {
// 部分移库 & 目标无同规格记录:减少原记录,新建目标记录
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity - ${toTransfer}`),
available_quantity: app.Sequelize.literal(`available_quantity - ${toTransfer}`),
updated_at: new Date(),
}, {
where: { id: srcRecord.id },
transaction,
});
const newRecord = await ctx.model.Storage.create({
warehouse_id: srcRecord.warehouse_id,
store_id: srcRecord.store_id,
space_id: targetSpaceId,
stock_id: srcRecord.stock_id,
batch_no: srcRecord.batch_no,
inventory_type: srcRecord.inventory_type,
quantity: toTransfer,
locked_quantity: 0,
available_quantity: toTransfer,
production_date: srcRecord.production_date,
expiry_date: srcRecord.expiry_date,
inbound_time: srcRecord.inbound_time,
inbound_order_no: srcRecord.inbound_order_no,
receiving_id: srcRecord.receiving_id,
entry_order_id: srcRecord.entry_order_id,
supplier_id: srcRecord.supplier_id,
supplier_batch_no: srcRecord.supplier_batch_no,
is_enabled: 1,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
targetStorageId = newRecord.id;
}
await this.createTransferStockTransactions({
transaction,
srcRecord,
transferQuantity: toTransfer,
sourceSpaceId: srcRecord.space_id,
targetSpaceId,
targetStorageId,
totalSnapshotQuantity: Number(stockWarehouseSnapshot.quantity) || 0,
totalSnapshotLockedQuantity: Number(stockWarehouseSnapshot.locked_quantity) || 0,
});
srcSpaceDelta.qtyDelta -= toTransfer;
tgtSpaceDelta.qtyDelta += toTransfer;
remainingQty -= toTransfer;
}
// ── 计算 SKU 维度统计变化 ──
const remainingSrcSku = await ctx.model.Storage.count({
where: {
space_id: spaceId,
stock_id: stockId,
is_enabled: 1,
delete_at: null,
},
transaction,
});
if (remainingSrcSku === 0) {
srcSpaceDelta.skuDelta -= 1;
}
if (tgtSkuCountBefore === 0) {
// 操作前目标库位没有该 SKU,现在有了
tgtSpaceDelta.skuDelta += 1;
}
// ────────── 8. 操作日志 ──────────
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'storage',
businessId: spaceId,
operationCode: 'STORAGE_TRANSFER_BY_PRODUCT',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId,
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
transfer_quantity: quantity,
affected_storage_count: affectedCount,
},
beforeChanges: {
space_id: spaceId,
stock_id: stockId,
total_available: totalAvailable,
source_record_count: srcRecords.length,
},
afterChanges: {
target_space_id: targetSpaceId,
transfer_quantity: quantity,
affected_storage_count: affectedCount,
},
});
} catch (logErr) {
ctx.logger.warn('[inventory.transferByProduct] 写入操作日志失败,不影响业务', logErr);
}
// ────────── 9. 更新库位统计 ──────────
const updateSpaceStats = async (updateSpaceId, delta) => {
if (delta.qtyDelta === 0 && delta.skuDelta === 0) return;
const updateFields = {};
if (delta.qtyDelta !== 0) {
updateFields.current_quantity = app.Sequelize.literal(
`GREATEST(COALESCE(current_quantity, 0) + (${delta.qtyDelta}), 0)`
);
}
if (delta.skuDelta !== 0) {
updateFields.current_sku_count = app.Sequelize.literal(
`GREATEST(COALESCE(current_sku_count, 0) + (${delta.skuDelta}), 0)`
);
}
await ctx.model.LocationSpace.update(updateFields, {
where: { id: updateSpaceId },
transaction,
});
};
await updateSpaceStats(spaceId, srcSpaceDelta);
await updateSpaceStats(targetSpaceId, tgtSpaceDelta);
// ────────── 10. 提交事务 ──────────
await transaction.commit();
// ────────── 11. 发送通知(事务外) ──────────
try {
await ctx.service.systems.notice.send({
event: 'storage_transfer_completed',
businessName: 'storage',
warehouseId,
subjectId: warehouseId,
title: '按商品移库操作完成',
content: `按商品移库完成:库位${spaceId} 商品${stockId} -> 库位${targetSpaceId}(数量:${quantity},涉及${affectedCount}条记录)`,
data: {
warehouse_id: warehouseId,
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
transfer_quantity: quantity,
affected_storage_count: affectedCount,
},
sender: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
});
} catch (noticeErr) {
ctx.logger.warn('[inventory.transferByProduct] 发送通知失败,不影响业务', noticeErr);
}
ctx.logger.info('[inventory.transferByProduct] 按商品移库完成', {
warehouse_id: warehouseId,
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
transfer_quantity: quantity,
affected_storage_count: affectedCount,
});
return {
code: 200,
message: '按商品移库完成',
data: {
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
transfer_quantity: quantity,
affected_storage_count: affectedCount,
warehouse_id: warehouseId,
},
};
} catch (error) {
await transaction.rollback();
ctx.logger.error('[inventory.transferByProduct] 按商品移库异常', {
space_id: spaceId,
stock_id: stockId,
target_space_id: targetSpaceId,
quantity,
error: error.message,
stack: error.stack,
});
if (error.name === 'SequelizeDatabaseError' && error.message.includes('Lock wait timeout')) {
return { code: 409, message: '库存记录被锁定,请稍后重试', data: null };
}
throw error;
}
}
/**
* API 入库单回调:向 api_app 配置的 callback_url 发送入库确认通知。
*
* @param {Object} entryOrder 入库单实例
* @return {Promise<Object>} { success, skipped?, status?, error? }
*/
async apiCallback(entryOrder) {
const { ctx, app } = this;
try {
const apiApp = await app.model.ApiApp.findOne({
where: {
warehouse_id: entryOrder.warehouse_id,
is_enabled: 1,
},
});
if (!apiApp || !apiApp.callback_url) {
ctx.logger.info('[matchPutaway] 未找到API回调配置或无回调地址,跳过回调');
return { success: true, skipped: true };
}
const items = await app.model.EntryItems.findAll({
where: { order_id: entryOrder.id },
});
const payload = {
entry_order_code: entryOrder.entry_order_code,
order_type: entryOrder.order_type,
order_status: 'COMPLETED',
warehouse_id: entryOrder.warehouse_id,
store_id: entryOrder.store_id,
items: items.map(item => ({
item_code: item.item_code,
item_id: item.item_id,
plan_quantity: item.count,
received_quantity: item.received_quantity,
confirm_quantity: item.received_quantity,
})),
confirm_time: new Date().toISOString(),
};
const response = await ctx.curl(apiApp.callback_url, {
method: 'POST',
contentType: 'json',
data: payload,
timeout: 10000,
dataType: 'json',
});
ctx.logger.info('[matchPutaway] API回调结果', {
entry_order_id: entryOrder.id,
callback_url: apiApp.callback_url,
status: response.status,
});
return { success: response.status === 200, status: response.status };
} catch (err) {
ctx.logger.error('[matchPutaway] API回调失败', err);
return { success: false, error: err.message };
}
}
/**
* 查询库存列表。
*
* 支持按批次明细或合并模式返回库存,并补充商品条码、图片附件、保质期预警和货主名称。
* 货主名称来源于货主签约表的 store_remask 字段,最终以 stock.store_name 输出。
*
* @param {Object} [pageParams={}] 分页参数
* @param {number} [pageParams.page=1] 页码
* @param {number} [pageParams.pageSize=20] 每页数量
* @param {Object} [sortParams={}] 排序参数
* @param {string} [sortParams.sortField='created_at'] 排序字段
* @param {string} [sortParams.sortOrder='DESC'] 排序方向
* @param {boolean} [groupByBatch=false] 是否按批次明细返回
* @return {Promise<{list: Object[], pagination: {page: number, pageSize: number, total: number, totalPages: number}}>} 库存列表结果
*/
async getInventoryList(pageParams = {}, sortParams = {}, groupByBatch = false) {
const { ctx, app } = this;
const { Op, fn, col, literal } = app.Sequelize;
const nowMs = Date.now();
const warehouseId = ctx.user.store_id;
const { page = 1, pageSize = 20 } = pageParams;
const { sortField = 'created_at', sortOrder = 'DESC' } = sortParams;
// 基础条件
const baseWhere = {
[Op.and]: [
{ warehouse_id: warehouseId },
{ is_enabled: 1 },
{ delete_at: null },
],
};
// 动态 where 条件
const parsed = ctx.whereParsed;
if (parsed && parsed.dynamicConditions && parsed.dynamicConditions.length > 0) {
baseWhere[Op.and].push(...parsed.dynamicConditions);
}
const offset = (page - 1) * pageSize;
const limit = pageSize;
if (groupByBatch) {
let inventoryWarningRanges = [];
try {
const store = await ctx.model.Store.findByPk(warehouseId, {
attributes: [ 'id', 'subject_config' ],
});
const normalizedSubjectConfig = ctx.model.Store.normalizeSubjectConfig(
store ? store.subject_config : null
);
inventoryWarningRanges = buildInventoryWarningRanges(
normalizedSubjectConfig && Array.isArray(normalizedSubjectConfig.inventory_warning_rules)
? normalizedSubjectConfig.inventory_warning_rules
: []
);
} catch (error) {
ctx.logger.warn(`[getInventoryList] 库存预警规则读取失败: ${error.message}`);
}
// 按批次明细:逐条返回
const { count: total, rows } = await ctx.model.Storage.findAndCountAll({
where: baseWhere,
order: [[ sortField, sortOrder ]],
offset,
limit,
include: [
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [
'id',
'item_code',
'item_name',
'sku_property',
'stock_unit',
'is_batch_mgmt',
'is_shelf_life_mgmt',
'remaining_threshold_days',
],
include: [
{
model: ctx.model.StoreWarehouse,
as: 'store_stock',
attributes: [ 'store_id', 'store_remask' ],
required: false,
},
],
required: false,
},
{
model: ctx.model.LocationSpace,
as: 'space',
attributes: [ 'id', 'space_code', 'custom_name' ],
required: false,
},
],
});
const list = rows.map(item => {
const row = item.get({ plain: true });
const shelfLifeWarningState = getShelfLifeWarningState(row.stock || {}, row.expiry_date, nowMs);
const inventoryWarningPayload = getInventoryWarningPayload(
shelfLifeWarningState.remainingDays,
inventoryWarningRanges
);
if (row.stock) {
row.stock.is_batch_mgmt_enabled = toBooleanFlag(row.stock.is_batch_mgmt);
row.stock.store_name = row.stock.store_stock?.store_remask || null;
delete row.stock.store_stock;
delete row.stock.is_batch_mgmt;
}
// 货主名称提升到根层级,便于前端直接使用
row.store_name = row.stock?.store_name || null;
row.created_at = row.created_at ? app.formatDate(row.created_at) : '';
row.updated_at = row.updated_at ? app.formatDate(row.updated_at) : '';
row.inbound_time = row.inbound_time ? app.formatDate(row.inbound_time) : '';
row.production_date = row.production_date ? app.formatDate(row.production_date) : '';
row.expiry_date = row.expiry_date ? app.formatDate(row.expiry_date) : '';
row.is_shelf_life_warning_triggered = shelfLifeWarningState.isTriggered;
row.expiry_remaining_days = inventoryWarningPayload.expiry_remaining_days;
row.inventory_warning_level = inventoryWarningPayload.inventory_warning_level;
row.inventory_warning_color = inventoryWarningPayload.inventory_warning_color;
row.inventory_warning_range = inventoryWarningPayload.inventory_warning_range;
row.inventory_warning_tip_text = inventoryWarningPayload.inventory_warning_tip_text;
return row;
});
await enrichInventoryStockAttachments(ctx, list);
return {
list,
pagination: {
page,
pageSize,
total,
totalPages: Math.ceil(total / pageSize),
},
};
}
// 不按批次:按 stock_id + space_id + inventory_type 合并
const groupFields = [ 'stock_id', 'space_id', 'inventory_type', 'warehouse_id', 'store_id' ];
const countResult = await ctx.model.Storage.count({
where: baseWhere,
group: groupFields,
});
const total = Array.isArray(countResult) ? countResult.length : countResult;
const rows = await ctx.model.Storage.findAll({
where: baseWhere,
attributes: [
'stock_id',
'space_id',
'inventory_type',
'warehouse_id',
'store_id',
[ fn('MIN', col('wms_storage.production_date')), 'production_date' ],
[ fn('MIN', col('wms_storage.expiry_date')), 'expiry_date' ],
[ fn('SUM', col('wms_storage.quantity')), 'quantity' ],
[ fn('SUM', col('wms_storage.locked_quantity')), 'locked_quantity' ],
[ fn('SUM', col('wms_storage.available_quantity')), 'available_quantity' ],
[ fn('MIN', col('wms_storage.inbound_time')), 'first_inbound_time' ],
[ fn('MAX', col('wms_storage.inbound_time')), 'last_inbound_time' ],
[ fn('COUNT', col('wms_storage.id')), 'batch_count' ],
],
group: groupFields,
order: [[ literal('last_inbound_time'), sortOrder ]],
offset,
limit,
include: [
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [
'id',
'item_code',
'item_name',
'sku_property',
'stock_unit',
'is_batch_mgmt',
'is_shelf_life_mgmt',
'remaining_threshold_days',
],
include: [
{
model: ctx.model.StoreWarehouse,
as: 'store_stock',
attributes: [ 'store_id', 'store_remask' ],
required: false,
},
],
required: false,
},
{
model: ctx.model.LocationSpace,
as: 'space',
attributes: [ 'id', 'space_code', 'custom_name' ],
required: false,
},
],
raw: true,
nest: true,
});
const list = rows.map(row => {
const shelfLifeWarningState = getShelfLifeWarningState(row.stock || {}, row.expiry_date, nowMs);
if (row.stock) {
row.stock.is_batch_mgmt_enabled = toBooleanFlag(row.stock.is_batch_mgmt);
row.stock.store_name = row.stock.store_stock?.store_remask || null;
delete row.stock.store_stock;
delete row.stock.is_batch_mgmt;
}
// 货主名称提升到根层级,便于前端直接使用
row.store_name = row.stock?.store_name || null;
row.first_inbound_time = row.first_inbound_time ? app.formatDate(row.first_inbound_time) : '';
row.last_inbound_time = row.last_inbound_time ? app.formatDate(row.last_inbound_time) : '';
row.production_date = row.production_date ? app.formatDate(row.production_date) : '';
row.expiry_date = row.expiry_date ? app.formatDate(row.expiry_date) : '';
row.is_shelf_life_warning_triggered = shelfLifeWarningState.isTriggered;
return row;
});
await enrichInventoryStockAttachments(ctx, list);
return {
list,
pagination: {
page,
pageSize,
total,
totalPages: Math.ceil(total / pageSize),
},
};
}
}
module.exports = InventoryService;