liufumingren 5ef99e3bed 1
2026-07-01 14:00:59 +08:00

1837 lines
62 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 { parseWhereConditions } = require('../../../lib/query_condition_parser');
class EntryService extends Service {
/**
* 将费用记录筛选值归一化为 0/1。
* @param {unknown} rawValue 原始筛选值
* @return {number|null} 归一化结果,无法识别时返回 null
*/
normalizeExpenseRecordValue(rawValue) {
if (rawValue === true) return 1;
if (rawValue === false) return 0;
if (rawValue === 1 || rawValue === '1') return 1;
if (rawValue === 0 || rawValue === '0') return 0;
if (typeof rawValue === 'string') {
const normalized = rawValue.trim().toLowerCase();
if ([ 'true', 'yes', 'y' ].includes(normalized)) return 1;
if ([ 'false', 'no', 'n' ].includes(normalized)) return 0;
}
return null;
}
/**
* 归一化 expense_record 条件,兼容 eq/in/布尔值写法。
* @param {Object|number|string|boolean} condition 原始条件
* @return {Object|null} 标准化后的条件,无法识别时返回 null
*/
normalizeExpenseRecordCondition(condition) {
const isObjectCondition = condition && typeof condition === 'object' && !Array.isArray(condition);
if (!isObjectCondition) {
const normalizedValue = this.normalizeExpenseRecordValue(condition);
if (normalizedValue === null) {
return null;
}
return {
operator: 'eq',
value: normalizedValue,
};
}
const operator = String(condition.operator || 'eq').trim().toLowerCase();
const values = this.normalizeFilterValues(condition)
.map(item => this.normalizeExpenseRecordValue(item))
.filter(item => item !== null);
if (values.length === 0) {
return null;
}
if (operator === 'in') {
return {
operator: 'in',
value: [ ...new Set(values) ],
};
}
return {
operator: 'eq',
value: values[0],
};
}
/**
* 将筛选值归一化为数组。
* @param {Object} condition 条件对象
* @return {Array<unknown>} 归一化后的值数组
*/
normalizeFilterValues(condition = {}) {
const value = condition && Object.prototype.hasOwnProperty.call(condition, 'value')
? condition.value
: undefined;
if (Array.isArray(value)) {
return value;
}
if (value === undefined || value === null) {
return [];
}
return [ value ];
}
/**
* 构建入库单-库存流水 EXISTS 子查询条件。
* @param {string} fieldName 流水字段名
* @param {Object} condition 条件对象
* @return {Object|null} Sequelize.where 条件,无法构建时返回 null
*/
buildEntryStockTransactionExistsCondition(fieldName, condition = {}) {
const { app, ctx } = this;
const db = ctx.model.sequelize;
const values = this.normalizeFilterValues(condition)
.map(item => (typeof item === 'string' ? item.trim() : item))
.filter(item => item !== '' && item !== undefined && item !== null);
if (values.length === 0) {
return null;
}
const operator = String(condition.operator || 'eq').trim().toLowerCase();
const escapedColumn = `st.${fieldName}`;
const escapedValues = values.map(item => db.escape(item));
let valueClause = '';
if (operator === 'in') {
valueClause = `${escapedColumn} IN (${escapedValues.join(',')})`;
} else if (operator === 'like' || operator === 'contains') {
const likeClauses = values.map(item => `${escapedColumn} LIKE ${db.escape(`%${String(item)}%`)}`);
valueClause = likeClauses.length === 1 ? likeClauses[0] : `(${likeClauses.join(' OR ')})`;
} else {
valueClause = `${escapedColumn} = ${escapedValues[0]}`;
}
const sql = `EXISTS (
SELECT 1
FROM wms_stock_transaction st
WHERE st.entry_order_id = wms_entry_order.id
AND ${valueClause}
)`;
return app.Sequelize.where(app.Sequelize.literal(sql), 1);
}
/**
* 预处理入库单列表筛选条件,兼容历史别名并构建扩展筛选。
* @param {Object} normalizedWhere 标准化后的 where 条件
* @return {{where: Object, extraConditions: Array<Object>, errorMessage: string}} 预处理结果
*/
/**
* 根据 hasReceiving 虚拟字段构建入库单 ID 筛选条件。
* @param {boolean} hasReceiving true=已绑定,false=未绑定
* @return {Promise<Object|null>} Sequelize where 条件,无需额外筛选时返回 null
*/
async buildHasReceivingCondition(hasReceiving) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const bindings = await ctx.model.EntryOrderReceiving.findAll({
attributes: [[ app.Sequelize.fn('DISTINCT', app.Sequelize.col('entry_order_id')), 'entry_order_id' ]],
where: { deleted_at: null },
raw: true,
});
const boundIds = bindings.map(item => item.entry_order_id);
if (hasReceiving === true) {
if (boundIds.length === 0) {
return { id: { [Op.eq]: null } };
}
return { id: { [Op.in]: boundIds } };
}
if (boundIds.length === 0) {
return null;
}
return { id: { [Op.notIn]: boundIds } };
}
/**
* 预处理入库单列表筛选条件,兼容历史别名并构建扩展筛选。
* @param {Object} normalizedWhere 标准化后的 where 条件
* @return {Promise<{where: Object, extraConditions: Array<Object>, errorMessage: string}>} 预处理结果
*/
async preprocessEntryListWhere(normalizedWhere = {}) {
const { ctx } = this;
const whereForParse = normalizedWhere && typeof normalizedWhere === 'object'
? { ...normalizedWhere }
: {};
const extraConditions = [];
if (whereForParse.erp_remark && !whereForParse.remark) {
whereForParse.remark = whereForParse.erp_remark;
}
delete whereForParse.erp_remark;
const batchCondition = whereForParse.batch_no || whereForParse.batch;
if (batchCondition) {
const existsCondition = this.buildEntryStockTransactionExistsCondition('batch_no', batchCondition);
if (existsCondition) {
extraConditions.push(existsCondition);
}
}
delete whereForParse.batch_no;
delete whereForParse.batch;
if (whereForParse.operator_id) {
const existsCondition = this.buildEntryStockTransactionExistsCondition('operator_id', whereForParse.operator_id);
if (existsCondition) {
extraConditions.push(existsCondition);
}
}
delete whereForParse.operator_id;
// 处理虚拟字段 hasReceiving:从 where 中剥离,构建绑定/未绑定筛选条件
if (Object.prototype.hasOwnProperty.call(whereForParse, 'hasReceiving')) {
const rawHasReceiving = whereForParse.hasReceiving;
delete whereForParse.hasReceiving;
if (rawHasReceiving === true || rawHasReceiving === false) {
const receivingCondition = await this.buildHasReceivingCondition(rawHasReceiving);
if (receivingCondition) {
extraConditions.push(receivingCondition);
}
}
}
if (Object.prototype.hasOwnProperty.call(whereForParse, 'expense_record')) {
const hasExpenseRecordField = Boolean(
ctx.model
&& ctx.model.EntryOrder
&& ctx.model.EntryOrder.rawAttributes
&& ctx.model.EntryOrder.rawAttributes.expense_record
);
if (!hasExpenseRecordField) {
return {
where: {},
extraConditions: [],
errorMessage: '当前环境未提供 expense_record 字段,暂不支持该筛选条件,请先完成表结构升级',
};
}
const normalizedExpenseRecord = this.normalizeExpenseRecordCondition(whereForParse.expense_record);
if (normalizedExpenseRecord) {
whereForParse.expense_record = normalizedExpenseRecord;
} else {
delete whereForParse.expense_record;
}
}
return {
where: whereForParse,
extraConditions,
errorMessage: '',
};
}
/**
* 入库单列表查询,复用 where 解构工具。
* @param {Object} where 筛选条件对象
* @param {Object} pageParams 分页参数
* @param {Object} sortParams 排序参数
* @return {Promise<Object>} code/data/message 结构
*/
async list(where = {}, pageParams = {}, sortParams = {}) {
const { ctx, app } = this;
const { Sequelize } = app;
const { Op } = Sequelize;
const page = Math.max(Number(pageParams.page) || 1, 1);
const pageSize = Math.max(Number(pageParams.pageSize) || 20, 1);
const sortField = sortParams.sortField || 'created_at';
const sortOrder = String(sortParams.sortOrder || 'DESC').toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
const validSortFields = [
'id',
'entry_order_code',
'order_type',
'order_status',
'order_create_time',
'created_at',
'updated_at',
'total_order_lines',
];
const actualSortField = validSortFields.includes(sortField) ? sortField : 'created_at';
const baseWhere = {
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
};
const normalizedWhere = ctx.where && typeof ctx.where === 'object'
? { ...ctx.where }
: (where && typeof where === 'object' ? { ...where } : {});
const {
where: parsedSourceWhere,
extraConditions,
errorMessage,
} = await this.preprocessEntryListWhere(normalizedWhere);
if (errorMessage) {
return {
code: 400,
message: errorMessage,
data: {
list: [],
pagination: {
page,
pageSize,
total: 0,
totalPages: 0,
hasPrevious: false,
hasNext: false,
},
summary: {
total: 0,
pending: 0,
creating: 0,
created: 0,
completed: 0,
cancelled: 0,
},
},
};
}
const parsed = parseWhereConditions({
where: parsedSourceWhere,
app,
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
if (!parsed.ok) {
return {
code: 400,
message: `筛选条件解析失败: ${parsed.reason}`,
data: {
list: [],
pagination: {
page,
pageSize,
total: 0,
totalPages: 0,
hasPrevious: false,
hasNext: false,
},
summary: {
total: 0,
pending: 0,
creating: 0,
created: 0,
completed: 0,
cancelled: 0,
},
},
};
}
const parsedResult = parsed.result;
const quickWhereInput = (parsedResult.rawConditionsByField && parsedResult.rawConditionsByField.quickWhere)
|| parsedSourceWhere.quickWhere
|| null;
const quickWhereValue = quickWhereInput && typeof quickWhereInput === 'object'
? quickWhereInput.value
: null;
const andConditions = [ baseWhere ];
if (quickWhereValue !== undefined && quickWhereValue !== null && String(quickWhereValue).trim() !== '') {
const kw = String(quickWhereValue).trim();
const receivingDetailId = Number(kw);
const orConditions = [
{ entry_order_code: { [Op.like]: `%${kw}%` } },
{ purchase_order_code: { [Op.like]: `%${kw}%` } },
{ supplier_name: { [Op.like]: `%${kw}%` } },
{ store_name: { [Op.like]: `%${kw}%` } },
{ warehouse_name: { [Op.like]: `%${kw}%` } },
// 搜索收货单明细 ID(箱唛/托盘唛唯一编码,精确数字匹配);仅当 kw 是有效正数时追加 EXISTS
...(Number.isFinite(receivingDetailId) && receivingDetailId > 0 ? [
Sequelize.where(Sequelize.literal(
`EXISTS (
SELECT 1 FROM wms_entry_order_receiving eor
JOIN wms_receiving_detail rd ON rd.receiving_id = eor.receiving_id
WHERE eor.entry_order_id = wms_entry_order.id
AND eor.deleted_at IS NULL
AND rd.id = ${receivingDetailId}
)`
), 1),
] : []),
];
andConditions.push({ [Op.or]: orConditions });
}
const dynamicConditions = parsedResult.dynamicConditions || [];
if (dynamicConditions.length > 0) {
andConditions.push({ [Op.and]: dynamicConditions });
}
if (extraConditions.length > 0) {
andConditions.push({ [Op.and]: extraConditions });
}
const finalWhere = { [Op.and]: andConditions };
const include = [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.Store,
as: 'store',
attributes: [ 'id', 'company_name' ],
required: false,
},
];
const { count, rows } = await ctx.model.EntryOrder.findAndCountAll({
where: finalWhere,
include,
order: [[ actualSortField, sortOrder ]],
limit: pageSize,
offset: (page - 1) * pageSize,
distinct: true,
});
// 批量查询收货单绑定信息
const entryOrderIds = rows.map(row => row.id);
/** @type {Map<number, Array<Object>>} */
const receivingBindingsMap = new Map();
if (entryOrderIds.length > 0) {
const allBindings = await ctx.model.EntryOrderReceiving.findAll({
where: { entry_order_id: { [Op.in]: entryOrderIds }, deleted_at: null },
include: [
{
model: ctx.model.Receiving,
as: 'receiving',
attributes: [ 'id', 'receiving_number', 'status', 'storage_status', 'created_at' ],
required: false,
},
],
order: [[ 'id', 'ASC' ]],
});
for (const binding of allBindings) {
const eid = binding.entry_order_id;
if (!receivingBindingsMap.has(eid)) {
receivingBindingsMap.set(eid, []);
}
receivingBindingsMap.get(eid).push(binding);
}
}
// 为每行附加收货单绑定信息
const enrichedRows = rows.map(row => {
const rowJSON = row.toJSON ? row.toJSON() : row;
const bindings = receivingBindingsMap.get(row.id) || [];
return {
...rowJSON,
receivingBindings: bindings,
hasReceiving: bindings.length > 0,
};
});
const statusRows = await ctx.model.EntryOrder.findAll({
attributes: [
'order_status',
[ Sequelize.fn('COUNT', Sequelize.col('id')), 'count' ],
],
where: finalWhere,
group: [ 'order_status' ],
raw: true,
});
const summary = {
total: count,
pending: 0,
creating: 0,
created: 0,
completed: 0,
cancelled: 0,
};
statusRows.forEach(item => {
const statusKey = String(item.order_status || '').toLowerCase();
if (Object.prototype.hasOwnProperty.call(summary, statusKey)) {
summary[statusKey] = Number(item.count) || 0;
}
});
return {
code: 200,
message: '查询成功',
data: {
list: enrichedRows,
pagination: {
page,
pageSize,
total: count,
totalPages: Math.ceil(count / pageSize),
hasPrevious: page > 1,
hasNext: page < Math.ceil(count / pageSize),
},
summary,
},
};
}
/**
* 查询入库单详情。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
/**
* 查询入库单详情,含商品信息、条码、入库进度。
* @param {Object} data 请求参数
* @param {number} [data.id] 入库单主键 ID
* @param {string} [data.entry_order_code] 入库单号
* @return {Promise<Object>} code/data/message 结构,data.entryOrder 为扁平化后的入库单详情
*/
async get(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
const entryOrderCode = data.entry_order_code ? String(data.entry_order_code).trim() : '';
const warehouseId = ctx.user.store_id;
if (!id && !entryOrderCode) {
return {
code: 400,
message: 'id 或 entry_order_code 至少传一个',
data: null,
};
}
const where = {
warehouse_id: warehouseId,
is_enabled: 1,
deleted_at: null,
};
if (id) {
where.id = id;
} else {
where.entry_order_code = entryOrderCode;
}
const entryOrder = await ctx.model.EntryOrder.findOne({
where,
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.Store,
as: 'store',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.EntryItems,
as: 'items',
attributes: [ 'id', 'order_id', 'out_biz_code', 'order_line_no', 'owner_code', 'item_code', 'item_id', 'count', 'inventory_type', 'stock_id', 'received_quantity', 'confirm_quantity' ],
required: false,
},
{
model: ctx.model.EntryOrderReceiving,
as: 'receivingBindings',
required: false,
include: [
{
model: ctx.model.Receiving,
as: 'receiving',
attributes: [ 'id', 'receiving_number', 'status', 'storage_status', 'created_at' ],
required: false,
},
],
},
],
});
if (!entryOrder) {
return {
code: 0,
message: '入库单不存在或无权访问',
data: null,
};
}
const entryOrderJSON = entryOrder.toJSON();
// 收集所有 stock_id,通过 getStockDetails 获取带缓存的商品详情
const stockIdSet = new Set();
if (entryOrderJSON.items && Array.isArray(entryOrderJSON.items)) {
for (const item of entryOrderJSON.items) {
if (item.stock_id != null) {
stockIdSet.add(Number(item.stock_id));
}
}
}
const stockIds = [ ...stockIdSet ];
/** @type {Map<number, Object>} */
const stockDetailMap = new Map();
if (stockIds.length > 0) {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId });
for (const detail of stockDetails) {
stockDetailMap.set(detail.id, detail);
}
}
// 查询该入库单所有商品的直接入库进度(非收货单途径)
const directInboundMap = {};
if (stockIds.length > 0) {
const directLogRows = await ctx.model.InboundDirectLog.findAll({
attributes: [
'stock_id',
[ ctx.app.Sequelize.fn('SUM', ctx.app.Sequelize.col('quantity')), 'total_quantity' ],
],
where: {
entry_order_code: entryOrderJSON.entry_order_code,
stock_id: { [ctx.app.Sequelize.Op.in]: stockIds },
},
group: [ 'stock_id' ],
raw: true,
});
for (const row of directLogRows) {
directInboundMap[row.stock_id] = Number(row.total_quantity) || 0;
}
}
// 扁平化 items:用 getStockDetails 返回的商品详情替换原有的 stock + barcodes
let flattenedItems;
if (entryOrderJSON.items && Array.isArray(entryOrderJSON.items)) {
flattenedItems = entryOrderJSON.items.map(item => {
const { item_code, item_id, stock_id: itemStockId, ...rest } = item;
const stockDetail = itemStockId != null ? stockDetailMap.get(Number(itemStockId)) || null : null;
const directInboundQty = (stockDetail && directInboundMap[stockDetail.id]) || 0;
const receivedQty = Number(rest.received_quantity) || 0;
const totalCount = Number(rest.count) || 0;
const remaining = Math.max(0, totalCount - receivedQty);
return {
...rest,
stock_id: itemStockId,
external_item_code: item_code,
external_item_id: item_id,
warehouse_item_code: (stockDetail && stockDetail.item_code) || '',
warehouse_item_name: (stockDetail && stockDetail.item_name) || '',
warehouse_item_spec: (stockDetail && stockDetail.sku_property) || '',
warehouse_quantity: (stockDetail && stockDetail.quantity != null) ? stockDetail.quantity : null,
warehouse_locked_quantity: (stockDetail && stockDetail.locked_quantity != null) ? stockDetail.locked_quantity : null,
warehouse_is_batch_mgmt: (stockDetail && stockDetail.is_batch_mgmt != null) ? stockDetail.is_batch_mgmt : null,
warehouse_is_shelf_life_mgmt: (stockDetail && stockDetail.is_shelf_life_mgmt != null) ? stockDetail.is_shelf_life_mgmt : null,
warehouse_image_url: (stockDetail && stockDetail.is_images === 'Y') ? '' : '',
warehouse_is_images: (stockDetail && stockDetail.is_images != null) ? stockDetail.is_images : null,
barcodes: (stockDetail && stockDetail.barcodes) || [],
direct_inbound_quantity: directInboundQty,
remaining_quantity: remaining,
};
});
} else {
flattenedItems = entryOrderJSON.items || [];
}
// 为每个 item 补充可匹配的收货单明细及剩余可用量
const enrichedItems = await this.enrichItemsWithAvailableReceivingDetails(flattenedItems, warehouseId);
entryOrderJSON.items = enrichedItems;
return {
code: 200,
message: '查询成功',
data: {
entryOrder: entryOrderJSON,
},
};
}
/**
* 为 entry items 批量补充可匹配的收货单明细及剩余可用量。
* 匹配规则:entry_item.stock_id 即 wms_stock_warehouse.id,与 wms_receiving_detail.system_product_id 直接对应。
* 只返回收货单状态为未完成(status NOT IN ('completed','cancelled'))且未完全入库(storage_status IN ('none','partial'))的明细。
* @param {Object[]} items 扁平化后的 entry items 数组
* @param {number} warehouseId 仓库ID
* @return {Promise<Object[]>} 补充了 available_receiving_details 的 items
*/
async enrichItemsWithAvailableReceivingDetails(items, warehouseId) {
if (!Array.isArray(items) || items.length === 0) return items;
const { ctx } = this;
const stockIds = [ ...new Set(items.map(i => Number(i.stock_id)).filter(Boolean)) ];
if (stockIds.length === 0) return items;
// stock_id 即 wms_stock_warehouse.id
// wms_receiving_detail.system_product_id 也指向 wms_stock_warehouse.id
// 所以映射关系就是 id → id,只需确认 stock_warehouse 记录存在
const swRows = await ctx.model.StockWarehouse.findAll({
where: { id: { [ctx.app.Sequelize.Op.in]: stockIds }, warehouse_id: warehouseId },
attributes: [ 'id' ],
raw: true,
});
const stockIdToSystemProductId = new Map();
for (const row of swRows) {
stockIdToSystemProductId.set(Number(row.id), Number(row.id));
}
const systemProductIds = [ ...new Set(stockIdToSystemProductId.values()) ];
if (systemProductIds.length === 0) return items;
// 批量查询收货单明细可用量
const rows = await ctx.model.query(
`SELECT
rd.id AS receiving_detail_id,
rd.receiving_id,
rd.system_product_id,
r.receiving_number,
rd.actual_quantity,
COALESCE(SUM(erb.allocated_quantity), 0) AS allocated_quantity,
rd.actual_quantity - COALESCE(SUM(erb.allocated_quantity), 0) AS available_quantity
FROM wms_receiving_detail rd
INNER JOIN wms_receiving r ON r.id = rd.receiving_id AND r.is_deleted = false
LEFT JOIN wms_entry_receiving_binding erb
ON erb.receiving_detail_id = rd.id
AND erb.status = 'committed'
AND erb.deleted_at IS NULL
WHERE rd.system_product_id IN (:systemProductIds)
AND r.status NOT IN ('completed', 'cancelled')
AND rd.storage_status IN ('none', 'partial')
GROUP BY rd.id, rd.receiving_id, rd.system_product_id, r.receiving_number, rd.actual_quantity
HAVING available_quantity > 0
ORDER BY rd.system_product_id, available_quantity DESC`,
{ replacements: { systemProductIds }, type: ctx.model.QueryTypes.SELECT }
);
// 按 system_product_id 分组
const mapBySystemProductId = new Map();
for (const row of rows) {
const spid = Number(row.system_product_id);
if (!mapBySystemProductId.has(spid)) mapBySystemProductId.set(spid, []);
mapBySystemProductId.get(spid).push({
receiving_id: Number(row.receiving_id),
receiving_number: String(row.receiving_number || '').trim(),
receiving_detail_id: Number(row.receiving_detail_id),
actual_quantity: Number(row.actual_quantity || 0),
allocated_quantity: Number(row.allocated_quantity || 0),
available_quantity: Number(row.available_quantity || 0),
});
}
// 为每个 item 挂载
return items.map(item => {
const sid = Number(item.stock_id);
const spid = stockIdToSystemProductId.get(sid) || 0;
return {
...item,
available_receiving_details: spid > 0 ? (mapBySystemProductId.get(spid) || []) : [],
};
});
}
/**
* 归一化作废入参中的入库单 ID 列表。
* 优先使用 ids;未传 ids 时回退到 id。
* @param {Object} data 请求体
* @return {{ ok: boolean, ids?: number[], code?: number, message?: string }} 归一化结果
*/
normalizeCancelEntryOrderIds(data = {}) {
const hasIdsField = Object.prototype.hasOwnProperty.call(data, 'ids');
const hasIdField = Object.prototype.hasOwnProperty.call(data, 'id');
if (!hasIdsField && !hasIdField) {
return {
ok: false,
code: 400,
message: 'id 或 ids 必填',
};
}
const rawIds = hasIdsField ? data.ids : [ data.id ];
if (hasIdsField) {
if (!Array.isArray(rawIds) || rawIds.length === 0) {
return {
ok: false,
code: 400,
message: 'ids 必须是非空数组',
};
}
} else if (!Number.isInteger(Number(rawIds[0])) || Number(rawIds[0]) <= 0) {
return {
ok: false,
code: 400,
message: 'id 必填且必须为正整数',
};
}
const normalizedIds = [];
for (const rawId of rawIds) {
const normalizedId = Number(rawId);
if (!Number.isInteger(normalizedId) || normalizedId <= 0) {
return {
ok: false,
code: 400,
message: 'ids 必须为正整数数组',
};
}
normalizedIds.push(normalizedId);
}
return {
ok: true,
ids: [ ...new Set(normalizedIds) ],
};
}
/**
* 查询当前仓库可访问的入库单。
* @param {number} id 入库单ID
* @return {Promise<Object|null>} 入库单实例
*/
async getOwnedEntryOrderById(id) {
const { ctx } = this;
return await ctx.model.EntryOrder.findOne({
where: {
id,
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
},
});
}
/**
* 作废入库单。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async cancel(data = {}) {
const { ctx } = this;
const normalizedResult = this.normalizeCancelEntryOrderIds(data);
if (!normalizedResult.ok) {
return {
code: normalizedResult.code || 400,
message: normalizedResult.message || '参数错误',
data: null,
};
}
const orderIds = normalizedResult.ids || [];
for (const orderId of orderIds) {
const entryOrder = await this.getOwnedEntryOrderById(orderId);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
// 6b: sync_status=SUCCESS 不可取消
if (entryOrder.sync_status === 'SUCCESS') {
return {
code: 400,
message: '入库单已完成回传,不可取消',
data: null,
};
}
if (entryOrder.order_status === 'COMPLETED') {
return {
code: 400,
message: '已完成入库单不允许作废',
data: null,
};
}
if (entryOrder.order_status === 'CANCELLED') {
return {
code: 400,
message: '入库单已作废',
data: null,
};
}
// 6a: QM 来源需发送取消同步
if (String(entryOrder.source_type) === 'QM') {
const entryItems = await ctx.model.EntryItems.findAll({
where: { order_id: entryOrder.id },
attributes: [ 'item_code', 'item_id', 'count', 'inventory_type', 'owner_code' ],
raw: true,
});
const orderLines = (entryItems || []).map((item, idx) => ({
orderLineNo: idx + 1,
ownerCode: item.owner_code || '',
itemCode: item.item_code || '',
itemId: item.item_id || '',
inventoryType: item.inventory_type || 'ZP',
planQty: item.count || 0,
actualQty: 0, // 全部为 0,通知 ERP 关闭
}));
const syncResult = await ctx.service.systems.inboundDirectLog.qimenEntrySync({
entryOrder,
orderLines,
outBizCode: `CANCEL_${Date.now()}`,
remark: '入库单取消',
operator: {
id: ctx.user?.employees_id || ctx.user?.id || '',
name: ctx.user?.employees_name || '',
},
});
if (!syncResult.success) {
return {
code: 500,
message: `取消失败: ${syncResult.message}`,
data: null,
};
}
}
// 更新状态
await entryOrder.update({
order_status: 'CANCELLED',
updated_at: new Date(),
});
// 回退关联收货单的入库状态,避免死锁
await this._rollbackReceivingStorageStatus(entryOrder.id);
// 写操作日志
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry_order',
businessId: entryOrder.id,
operationCode: 'ENTRY_ORDER_CANCEL',
operator: {
id: ctx.user?.employees_id || ctx.user?.id || '',
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId: entryOrder.warehouse_id,
message: '入库单已取消',
},
});
}
return {
code: 200,
message: '作废成功',
data: { ids: orderIds },
};
}
/**
* 回退入库单关联收货单的入库状态(入库单作废时调用)。
* 失败不阻塞主流程,仅打印日志。
* @param {number} entryOrderId 入库单ID
* @return {Promise<void>}
*/
async _rollbackReceivingStorageStatus(entryOrderId) {
const { ctx } = this;
try {
// 1. 查询关联的收货单ID列表
const bindings = await ctx.model.EntryOrderReceiving.findAll({
where: { entry_order_id: entryOrderId, deleted_at: null },
attributes: [ 'receiving_id' ],
raw: true,
});
const receivingIds = (bindings || [ ]).map(b => b.receiving_id).filter(Boolean);
if (receivingIds.length === 0) {
return;
}
// 2. 回退收货单主表 storage_status → 'none'
await ctx.model.Receiving.update(
{ storage_status: 'none', updated_at: new Date() },
{ where: { id: { [ctx.app.Sequelize.Op.in]: receivingIds } } }
);
// 3. 回退收货单明细 storage_status → 'none', stored_quantity → 0
await ctx.model.ReceivingDetail.update(
{ storage_status: 'none', stored_quantity: 0, updated_at: new Date() },
{ where: { receiving_id: { [ctx.app.Sequelize.Op.in]: receivingIds } } }
);
ctx.logger.info(
`[storage.entry.cancel] 入库单 ${entryOrderId} 作废,已回退收货单入库状态,receivingIds=[${receivingIds.join(',')}]`
);
} catch (err) {
ctx.logger.error(
`[storage.entry.cancel] 回退收货单入库状态失败,entryOrderId=${entryOrderId},err=${err.message}`
);
}
}
/**
* 获取入库单的导入/PDA 直接入库信息(转发到 inboundDirectLog)。
* @param {string} entryOrderCode 入库单号
* @return {Promise<Object>} code/data/message 结构
*/
async getDirectInboundItems(entryOrderCode) {
const { ctx } = this;
return await ctx.service.systems.inboundDirectLog.getItems(entryOrderCode);
}
/**
* 按商品增量添加导入/PDA 直接入库记录(转发到 inboundDirectLog)。
* @param {Object} data 请求体
* @param {string} data.entry_order_code 入库单号
* @param {number} [data.stock_id] 商品SKU ID(单条模式)
* @param {number} [data.quantity] 本次入库数量(单条模式)
* @param {string} [data.inbound_type] 入库方式(单条模式)
* @param {Array} [data.items] 商品列表(批量模式)
* @return {Promise<Object>} code/data/message 结构
*/
async addDirectInboundItem(data = {}) {
const { ctx } = this;
return await ctx.service.systems.inboundDirectLog.addItem(data);
}
/**
* 提交确认完成导入/PDA 直接入库(转发到 inboundDirectLog)。
* @param {string} entryOrderCode 入库单号
* @return {Promise<Object>} code/data/message 结构
*/
async commitDirectInbound(entryOrderCode) {
const { ctx } = this;
return await ctx.service.systems.inboundDirectLog.commit(entryOrderCode);
}
/**
* 移除一条导入/PDA 直接入库记录(转发到 inboundDirectLog)。
* @param {Object} data 请求体
* @param {number} data.id 入库记录ID
* @return {Promise<Object>} code/data/message 结构
*/
async removeDirectInboundItem(data = {}) {
const { ctx } = this;
return await ctx.service.systems.inboundDirectLog.removeItem(data);
}
/**
* 查询入库单已绑定收货单中匹配指定 stock_id 的收货明细列表。
* 用于 PDA 导入时选择要绑定的收货明细。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @param {number} data.stock_id 商品 stock_id
* @return {Promise<Object>} { code, message, data: { list: [{ receiving_detail_id, receiving_id, receiving_number, actual_quantity, used_quantity, available_quantity, system_product_id }] } }
*/
async getReceivingDetailsForBind(data = {}) {
const { ctx, app } = this;
const entryOrderId = Number(data.entry_order_id);
const stockId = Number(data.stock_id);
if (!entryOrderId || !stockId) {
return { code: 400, message: 'entry_order_id 和 stock_id 必填', data: null };
}
// 1. 查入库单绑定的收货单 ID 列表
const orderReceivings = await ctx.model.EntryOrderReceiving.findAll({
where: { entry_order_id: entryOrderId, deleted_at: null },
attributes: [ 'receiving_id' ],
raw: true,
});
if (!orderReceivings.length) {
return { code: 200, message: 'ok', data: { list: [] } };
}
const receivingIds = orderReceivings.map(r => r.receiving_id);
// 2. 查收货明细(system_product_id = stockId,且收货单未取消/未删除)
const details = await ctx.model.ReceivingDetail.findAll({
where: {
system_product_id: stockId,
receiving_id: receivingIds,
deleted_at: null,
},
attributes: [ 'id', 'receiving_id', 'actual_quantity', 'system_product_id' ],
include: [{
model: ctx.model.Receiving,
as: 'receiving',
attributes: [ 'id', 'receiving_number', 'status' ],
where: { status: { [ app.Sequelize.Op.ne ]: 'cancelled' }, deleted_at: null },
required: true,
}],
raw: false,
});
// 3. 查每个明细的已占用数量(pending + committed)
const detailIds = details.map(d => d.id);
const usedMap = new Map();
if (detailIds.length > 0) {
const usedRows = await ctx.model.query(
`SELECT receiving_detail_id, COALESCE(SUM(allocated_quantity), 0) AS used_qty
FROM wms_entry_receiving_binding
WHERE receiving_detail_id IN (:ids)
AND status IN ('pending', 'committed')
AND deleted_at IS NULL
GROUP BY receiving_detail_id`,
{
replacements: { ids: detailIds },
type: ctx.model.QueryTypes.SELECT,
}
);
for (const row of usedRows) {
usedMap.set(row.receiving_detail_id, Number(row.used_qty));
}
}
// 4. 组装返回
const list = details.map(d => {
const rid = d.id;
const used = usedMap.get(rid) || 0;
return {
receiving_detail_id: rid,
receiving_id: d.receiving_id,
receiving_number: d.receiving?.receiving_number || '',
actual_quantity: d.actual_quantity || 0,
used_quantity: used,
available_quantity: Math.max(0, (d.actual_quantity || 0) - used),
system_product_id: d.system_product_id,
};
});
return { code: 200, message: 'ok', data: { list } };
}
/**
* 拉取入库单绑定的收货单中,指定商品的可用容器列表(收货明细)。
* 用于 PDA 上架时选择容器。
* @param {Object} data 请求参数
* @param {number} data.entry_order_id 入库单ID
* @param {number} data.stock_id 商品stock_id
* @return {Promise<Object>} { code, message, data: { list, total } }
*/
async containerList(data = {}) {
const { ctx, app } = this;
const warehouseId = ctx.user?.store_id;
const entryOrderId = Number(data.entry_order_id);
const stockId = Number(data.stock_id);
// 参数校验
if (!warehouseId) {
return { code: 0, message: '用户未绑定仓库', data: null };
}
if (!entryOrderId || entryOrderId <= 0) {
return { code: 0, message: 'entry_order_id 不能为空', data: null };
}
if (!stockId || stockId <= 0) {
return { code: 0, message: 'stock_id 不能为空', data: null };
}
try {
// 1. 验证入库单存在且属于当前仓库
const entryOrder = await ctx.model.EntryOrder.findOne({
where: {
id: entryOrderId,
warehouse_id: warehouseId,
},
attributes: [ 'id' ],
raw: true,
});
if (!entryOrder) {
return { code: 0, message: '入库单不存在或无权访问', data: null };
}
// 2. 通过 wms_entry_order_receiving 查出关联的 receiving_id 列表
const entryReceivingRows = await ctx.model.EntryOrderReceiving.findAll({
where: { entry_order_id: entryOrderId, deleted_at: null },
attributes: [ 'receiving_id' ],
raw: true,
});
const receivingIds = entryReceivingRows.map(r => r.receiving_id).filter(Boolean);
if (receivingIds.length === 0) {
return { code: 200, message: 'ok', data: { list: [], total: 0 } };
}
// 3. 排除已绑定的收货明细(wms_entry_receiving_binding 中有记录且未软删除)
const notBoundCondition = app.Sequelize.literal(
'NOT EXISTS (SELECT 1 FROM wms_entry_receiving_binding erb WHERE erb.receiving_detail_id = wms_receiving_detail.id AND erb.deleted_at IS NULL)'
);
// 4. 查询指定商品的未绑定收货明细
const details = await ctx.model.ReceivingDetail.findAll({
where: {
[app.Sequelize.Op.and]: [
{ system_product_id: stockId },
{ receiving_id: { [app.Sequelize.Op.in]: receivingIds } },
notBoundCondition,
],
},
raw: true,
});
// 5. 收集所有明细的 system_product_id,批量获取 stock 详情
const stockIdSet = new Set();
for (const d of details) {
if (d.system_product_id != null) {
stockIdSet.add(Number(d.system_product_id));
}
}
const stockIds = [ ...stockIdSet ];
/** @type {Map<number, Object>} */
const stockDetailMap = new Map();
if (stockIds.length > 0) {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId });
for (const sd of stockDetails) {
if (sd && sd.id != null) {
stockDetailMap.set(sd.id, sd);
}
}
}
// 6. 组装返回结果
const list = details.map(detail => ({
detail_id: detail.id,
receiving_id: detail.receiving_id,
barcode: detail.barcode || '',
product_name: detail.product_name || '',
actual_quantity: detail.actual_quantity || 0,
receiving_status: detail.receiving_status || '',
stock: stockDetailMap.get(Number(detail.system_product_id)) || null,
}));
return {
code: 200,
message: 'ok',
data: {
list,
total: list.length,
},
};
} catch (error) {
ctx.logger.error('[storage.entry.containerList] 查询容器列表失败', error);
return { code: 500, message: `服务器错误: ${error.message}`, data: null };
}
}
/**
* 快捷直入/虚拟入库:将入库单的所有商品按明细数量全部直入到虚拟库位(space_id=2),跳过收货、质检等正常流程。
* 采用"先同步后写库"两段式:① 先发奇门/OpenAPI 回传,② 回传成功后再开启事务写库存。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @return {Promise<Object>} code/data/message 结构
*/
async quickInbound(data = {}) {
const { ctx, app } = this;
const orderId = Number(data.id || 0);
if (!orderId) {
return {
code: 400,
message: 'id 必填',
data: null,
};
}
// 1. 校验入库单
const entryOrder = await this.getOwnedEntryOrderById(orderId);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
if (entryOrder.order_status !== 'CREATED') {
if (entryOrder.order_status === 'CANCELLED') {
return {
code: 400,
message: '已作废入库单不允许快捷入库',
data: null,
};
}
if (entryOrder.order_status === 'COMPLETED') {
return {
code: 400,
message: '入库单已完成,请勿重复提交',
data: null,
};
}
return {
code: 400,
message: `入库单状态不允许快捷直入,当前状态:${entryOrder.order_status}`,
data: null,
};
}
// 2. 查询入库单所有明细
const entryItems = await ctx.model.EntryItems.findAll({
where: { order_id: entryOrder.id },
});
if (!entryItems.length) {
return {
code: 400,
message: '请先添加入库明细',
data: null,
};
}
// ===== 阶段一 + 阶段二合并为统一调用 =====
const syncResult = await ctx.service.systems.inboundDirectLog.qimenEntrySync({
entryOrder,
orderLines: entryItems.map((item, idx) => ({
orderLineNo: idx + 1,
ownerCode: item.owner_code || '',
itemCode: item.item_code || '',
itemId: item.item_id || '',
inventoryType: item.inventory_type || 'ZP',
planQty: Number(item.count) || 0,
actualQty: Number(item.count) || 0,
})),
outBizCode: `DIRECT_INBOUND_${Date.now()}`,
remark: '导入/PDA直接入库提交',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
onSuccess: async eo => {
const warehouseId = eo.warehouse_id;
const storeId = eo.store_id;
const batchNo = eo.entry_order_code;
const hardcodedSpaceId = 2;
const transaction = await ctx.model.transaction();
const processedStockIds = new Set();
let totalInboundQty = 0;
try {
for (const item of entryItems) {
const stockId = item.stock_id;
if (!stockId) continue;
const planQty = Number(item.count) || 0;
if (planQty <= 0) continue;
const inventoryType = item.inventory_type || 'ZP';
await ctx.model.EntryItems.update({
received_quantity: planQty,
}, {
where: { id: item.id },
transaction,
});
if (processedStockIds.has(String(stockId))) continue;
processedStockIds.add(String(stockId));
totalInboundQty += planQty;
const stockRecord = await ctx.model.StockWarehouse.findOne({
where: { id: stockId, is_valid: 'Y', deleted_at: null },
lock: transaction.LOCK.UPDATE,
transaction,
});
if (stockRecord) {
const beforeQuantity = Number(stockRecord.quantity) || 0;
const beforeLockedQuantity = Number(stockRecord.locked_quantity) || 0;
await stockRecord.increment('quantity', { by: planQty, transaction, silent: true });
await stockRecord.reload({ transaction });
const afterQuantity = Number(stockRecord.quantity) || 0;
const afterLockedQuantity = Number(stockRecord.locked_quantity) || 0;
await ctx.service.systems.stockTransaction.create({
transaction_type: 'INBOUND',
warehouse_id: warehouseId,
store_id: storeId,
stock_id: stockId,
quantity: planQty,
batch_no: batchNo,
order_type: eo.order_type,
order_no: eo.entry_order_code,
entry_order_id: eo.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 });
}
const storageRecord = await ctx.model.Storage.findOne({
where: {
space_id: hardcodedSpaceId,
stock_id: stockId,
batch_no: batchNo,
inventory_type: inventoryType,
is_enabled: 1,
delete_at: null,
},
lock: transaction.LOCK.UPDATE,
transaction,
});
let storageId = null;
let storageBeforeQty = 0;
let storageAfterQty = 0;
if (storageRecord) {
storageBeforeQty = Number(storageRecord.quantity) || 0;
storageAfterQty = storageBeforeQty + planQty;
await ctx.model.Storage.update({
quantity: app.Sequelize.literal(`quantity + ${planQty}`),
available_quantity: app.Sequelize.literal(`available_quantity + ${planQty}`),
entry_order_id: eo.id,
inbound_time: new Date(),
inbound_order_no: eo.entry_order_code,
updated_at: new Date(),
}, {
where: { id: storageRecord.id },
transaction,
});
storageId = storageRecord.id;
} else {
storageBeforeQty = 0;
storageAfterQty = planQty;
const createdStorage = await ctx.model.Storage.create({
warehouse_id: warehouseId,
store_id: storeId,
space_id: hardcodedSpaceId,
stock_id: stockId,
batch_no: batchNo,
inventory_type: inventoryType,
quantity: planQty,
locked_quantity: 0,
available_quantity: planQty,
inbound_time: new Date(),
inbound_order_no: eo.entry_order_code,
receiving_id: null,
entry_order_id: eo.id,
supplier_id: null,
supplier_batch_no: null,
is_enabled: 1,
created_at: new Date(),
updated_at: new Date(),
}, { transaction });
storageId = createdStorage.id;
}
// 写入库位维度库存流水
await ctx.model.StorageTransaction.create({
transaction_type: 'INBOUND',
warehouse_id: warehouseId,
store_id: storeId,
stock_id: stockId,
storage_id: storageId,
space_id: hardcodedSpaceId,
quantity: planQty,
before_quantity: storageBeforeQty,
after_quantity: storageAfterQty,
batch_no: batchNo,
inventory_type: inventoryType,
order_type: 'entry_order',
order_no: eo.entry_order_code,
order_id: eo.id,
operator_id: String(ctx.user?.employees_id || ctx.user?.id || ''),
operator_name: ctx.user?.employees_name || '',
remark: '快捷直入/虚拟入库',
created_at: new Date(),
}, { transaction });
}
await eo.update({
order_status: 'COMPLETED',
sync_status: 'SUCCESS',
sync_message: JSON.stringify({
completedAt: new Date(),
totalQuantity: totalInboundQty,
itemCount: processedStockIds.size,
source: 'quick_inbound',
}),
updated_at: new Date(),
}, { transaction });
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry_order',
businessId: eo.id,
operationCode: 'QUICK_INBOUND',
operator: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId: eo.warehouse_id,
message: `快捷直入完成,共 ${processedStockIds.size} 种商品,总数量 ${totalInboundQty}`,
},
transaction,
});
await transaction.commit();
} catch (error) {
if (transaction && typeof transaction.rollback === 'function') {
await transaction.rollback();
}
throw error;
}
},
});
if (!syncResult.success) {
return {
code: 500,
message: syncResult.message,
data: {
id: entryOrder.id,
entry_order_code: entryOrder.entry_order_code,
sync_status: 'FAILED',
},
};
}
return {
code: 200,
message: '快捷入库完成',
data: {
id: entryOrder.id,
entry_order_code: entryOrder.entry_order_code,
order_status: 'COMPLETED',
sync_status: 'SUCCESS',
items_count: entryItems.length,
total_quantity: entryItems.reduce((s, item) => s + (Number(item.count) || 0), 0),
},
};
}
/**
* 入库单商品与收货单商品逐行对照视图(支持多个收货单)。
* 以入库单明细为主,按 stock_id ↔ system_product_id 匹配收货单明细,
* 返回每个收货单的匹配/未匹配/收货单多余对照结果及汇总。
*
* @param {Object} data 请求参数
* @param {number} data.entry_order_id 入库单ID
* @param {number[]} [data.receiving_ids] 收货单ID列表(优先使用)
* @param {number} [data.receiving_id] 单个收货单ID(向后兼容,receiving_ids 优先)
* @return {Promise<Object>} code/data/message 结构
*/
async receivingCompare(data = {}) {
const { ctx } = this;
const entryOrderId = Number(data.entry_order_id || 0);
const warehouseId = ctx.user.store_id;
// 入参处理:receiving_ids 优先,receiving_id 向后兼容
let receivingIds = data.receiving_ids;
if (!Array.isArray(receivingIds) || receivingIds.length === 0) {
const singleId = Number(data.receiving_id || 0);
if (singleId) {
receivingIds = [ singleId ];
} else {
return { code: 400, message: 'receiving_ids 或 receiving_id 必填', data: null };
}
}
receivingIds = [ ...new Set(receivingIds.map(id => Number(id)).filter(Boolean)) ];
if (!entryOrderId) {
return { code: 400, message: 'entry_order_id 必填', data: null };
}
// 1. 校验入库单存在性
const entryOrder = await this.getOwnedEntryOrderById(entryOrderId);
if (!entryOrder) {
return { code: 404, message: '入库单不存在或无权访问', data: null };
}
// 2. 查询入库单明细(所有收货单共用)
const entryItems = await ctx.model.EntryItems.findAll({
where: { order_id: entryOrderId },
attributes: [ 'id', 'stock_id', 'count', 'received_quantity' ],
raw: true,
});
// 3. 收集入库单所有 stock_id
const entryStockIds = [ ...new Set(entryItems.map(item => Number(item.stock_id)).filter(Boolean)) ];
// 4. 对每个收货单执行对比
const comparisons = [];
const errors = [];
for (const receivingId of receivingIds) {
const singleResult = await this._compareSingleReceiving({
receivingId,
warehouseId,
entryOrderId,
entryOrder,
entryItems,
entryStockIds,
});
if (singleResult._error) {
errors.push(singleResult._error);
} else {
comparisons.push(singleResult);
}
}
const totalReceivings = receivingIds.length;
const matchedCount = comparisons.length;
const errorCount = errors.length;
return {
code: 200,
message: '查询成功',
data: {
entry_order_id: entryOrderId,
entry_order_code: entryOrder.entry_order_code,
comparisons,
errors,
total_summary: {
total_receivings: totalReceivings,
matched_count: matchedCount,
error_count: errorCount,
},
},
};
}
/**
* 对单个收货单执行商品对照逻辑。
* @param {Object} params 参数
* @param {number} params.receivingId 收货单ID
* @param {number} params.warehouseId 仓库ID
* @param {number} params.entryOrderId 入库单ID
* @param {Object} params.entryOrder 入库单记录
* @param {Object[]} params.entryItems 入库单明细列表
* @param {number[]} params.entryStockIds 入库单 stock_id 集合
* @return {Promise<Object>} 单个收货单的对照结果,或 { _error: ... }
*/
async _compareSingleReceiving(params = {}) {
const { ctx, app } = this;
const { receivingId, warehouseId, entryItems, entryStockIds } = params;
// 校验收货单存在性与仓库匹配
const receivingOrder = await ctx.model.Receiving.findOne({
where: {
id: receivingId,
warehouse_id: warehouseId,
is_deleted: false,
},
attributes: [ 'id', 'receiving_number', 'status', 'storage_status' ],
raw: true,
});
if (!receivingOrder) {
return {
_error: {
receiving_id: receivingId,
status: 'error',
error_code: 'RECEIVING_NOT_FOUND',
error_message: '收货单不存在或无权访问',
},
};
}
// 查询收货单明细
const receivingDetails = await ctx.model.ReceivingDetail.findAll({
where: { receiving_id: receivingId },
attributes: [ 'id', 'system_product_id', 'actual_quantity', 'product_name' ],
raw: true,
});
// 收集所有 stock_id,批量查询商品信息
const receivingSystemProductIds = [ ...new Set(receivingDetails.map(d => Number(d.system_product_id)).filter(Boolean)) ];
const allStockIds = [ ...new Set([ ...entryStockIds, ...receivingSystemProductIds ]) ];
const stockDetailMap = new Map();
if (allStockIds.length > 0) {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(allStockIds, { warehouseId });
for (const detail of stockDetails) {
stockDetailMap.set(detail.id, detail);
}
}
// stock_id ↔ system_product_id 映射
const stockIdToSystemProductId = new Map();
const systemProductIdToEntryStockIds = new Map();
if (entryStockIds.length > 0) {
const swRows = await ctx.model.StockWarehouse.findAll({
where: { id: { [app.Sequelize.Op.in]: entryStockIds }, warehouse_id: warehouseId },
attributes: [ 'id' ],
raw: true,
});
for (const row of swRows) {
const stockId = Number(row.id);
stockIdToSystemProductId.set(stockId, stockId);
if (!systemProductIdToEntryStockIds.has(stockId)) {
systemProductIdToEntryStockIds.set(stockId, []);
}
systemProductIdToEntryStockIds.get(stockId).push(stockId);
}
}
// 查询已分配量(限定本入库单的 entry_items,避免全局绑定干扰)
const receivingDetailIds = receivingDetails.map(d => d.id);
const entryItemIds = entryItems.map(ei => ei.id);
const allocatedMap = new Map();
if (receivingDetailIds.length > 0 && entryItemIds.length > 0) {
const bindingRows = await ctx.model.EntryReceivingBinding.findAll({
attributes: [
'receiving_detail_id',
[ app.Sequelize.fn('SUM', app.Sequelize.col('allocated_quantity')), 'total_allocated' ],
],
where: {
entry_item_id: { [app.Sequelize.Op.in]: entryItemIds },
receiving_detail_id: { [app.Sequelize.Op.in]: receivingDetailIds },
status: { [app.Sequelize.Op.in]: [ 'pending', 'committed' ] },
deleted_at: null,
},
group: [ 'receiving_detail_id' ],
raw: true,
});
for (const row of bindingRows) {
allocatedMap.set(Number(row.receiving_detail_id), Number(row.total_allocated) || 0);
}
}
// 构建对照视图:以入库单明细为主
const comparison = [];
const matchedReceivingDetailIds = new Set();
for (const entryItem of entryItems) {
const stockId = Number(entryItem.stock_id || 0);
const systemProductId = stockIdToSystemProductId.get(stockId) || 0;
const stockDetail = stockDetailMap.get(stockId) || null;
const matchedReceiving = systemProductId > 0
? receivingDetails.filter(rd => Number(rd.system_product_id) === systemProductId)
: [];
if (matchedReceiving.length > 0) {
for (const rd of matchedReceiving) {
matchedReceivingDetailIds.add(rd.id);
const rdStockDetail = (rd.system_product_id != null && stockDetailMap.get(Number(rd.system_product_id))) || null;
const allocated = allocatedMap.get(Number(rd.id)) || 0;
const available = Math.max(0, (Number(rd.actual_quantity) || 0) - allocated);
comparison.push({
entry_item_id: Number(entryItem.id),
stock_id: stockId,
warehouse_item_code: (stockDetail && stockDetail.item_code) || '',
warehouse_item_name: (stockDetail && stockDetail.item_name) || '',
warehouse_item_spec: (stockDetail && stockDetail.sku_property) || '',
entry_count: Number(entryItem.count) || 0,
entry_received: Number(entryItem.received_quantity) || 0,
receiving_detail_id: Number(rd.id),
receiving_product_code: (rdStockDetail && rdStockDetail.item_code) || '',
receiving_product_name: rd.product_name || (rdStockDetail && rdStockDetail.item_name) || '',
receiving_actual_quantity: Number(rd.actual_quantity) || 0,
receiving_allocated: allocated,
receiving_available: available,
match_status: 'matched',
});
}
} else {
comparison.push({
entry_item_id: Number(entryItem.id),
stock_id: stockId,
warehouse_item_code: (stockDetail && stockDetail.item_code) || '',
warehouse_item_name: (stockDetail && stockDetail.item_name) || '',
warehouse_item_spec: (stockDetail && stockDetail.sku_property) || '',
entry_count: Number(entryItem.count) || 0,
entry_received: Number(entryItem.received_quantity) || 0,
receiving_detail_id: null,
receiving_product_code: null,
receiving_product_name: null,
receiving_actual_quantity: null,
receiving_allocated: null,
receiving_available: null,
match_status: 'entry_only',
});
}
}
// 收货单中多余的商品
const receivingOnly = [];
const receivingStockMap = new Map();
for (const rd of receivingDetails) {
if (!matchedReceivingDetailIds.has(Number(rd.id))) {
const rdStockDetail = (rd.system_product_id != null && stockDetailMap.get(Number(rd.system_product_id))) || null;
const stockId = rd.system_product_id != null ? Number(rd.system_product_id) : null;
const qty = Number(rd.actual_quantity) || 0;
const name = rd.product_name || (rdStockDetail && rdStockDetail.item_name) || '';
const allocated = allocatedMap.get(Number(rd.id)) || 0;
const available = Math.max(0, qty - allocated);
if (stockId === null) {
receivingOnly.push({
receiving_product_name: name,
receiving_actual_quantity: qty,
receiving_allocated: allocated,
receiving_available: available,
});
} else if (receivingStockMap.has(stockId)) {
const existing = receivingStockMap.get(stockId);
existing.receiving_actual_quantity += qty;
existing.receiving_allocated += allocated;
existing.receiving_available += available;
if (!existing.receiving_product_name && name) {
existing.receiving_product_name = name;
}
} else {
receivingStockMap.set(stockId, {
receiving_product_name: name,
receiving_actual_quantity: qty,
receiving_allocated: allocated,
receiving_available: available,
});
}
}
}
for (const item of receivingStockMap.values()) {
item.receiving_available = Math.max(0, item.receiving_available);
receivingOnly.push(item);
}
// 汇总
const matchedItems = comparison.filter(c => c.match_status === 'matched').length;
const entryOnlyItems = comparison.filter(c => c.match_status === 'entry_only').length;
return {
receiving_id: receivingId,
receiving_number: receivingOrder.receiving_number,
status: 'matched',
comparison,
receiving_only: receivingOnly,
summary: {
total_entry_items: entryItems.length,
matched_items: matchedItems,
entry_only_items: entryOnlyItems,
receiving_only_items: receivingOnly.length,
},
};
}
}
module.exports = EntryService;