1922 lines
65 KiB
JavaScript
1922 lines
65 KiB
JavaScript
'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 } = this;
|
||
const db = app.model;
|
||
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 escapedKw = app.model.escape(`%${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}%` } },
|
||
// 搜索收货单号(wms_receiving.receiving_number),通过绑定表关联
|
||
Sequelize.where(Sequelize.literal(
|
||
`EXISTS (
|
||
SELECT 1 FROM wms_entry_order_receiving eor
|
||
JOIN wms_receiving r ON r.id = eor.receiving_id
|
||
WHERE eor.entry_order_id = wms_entry_order.id
|
||
AND eor.deleted_at IS NULL
|
||
AND r.receiving_number LIKE ${escapedKw}
|
||
)`
|
||
), 1),
|
||
// 搜索收货单明细 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 结构
|
||
*/
|
||
/**
|
||
* 查询入库单详情(与原 storage.directInbound.getItems 输出格式一致)。
|
||
* 返回入库单基本信息、商品明细(含计划数量与已完成数量)、收货单绑定关系。
|
||
* @param {Object} data 请求参数
|
||
* @param {number} data.id 入库单主键 ID(必填)
|
||
* @return {Promise<Object>} code/data/message 结构
|
||
* - data.entryOrder: { id, entry_order_code, order_status, store_remask }
|
||
* - data.items: [{ id, stock_id, planned, completed, stock, bindings }]
|
||
* - data.receivingBindings: [{ id, receiving_id, receiving }]
|
||
*/
|
||
async get(data = {}) {
|
||
const { ctx, app } = this;
|
||
const id = Number(data.id || 0);
|
||
|
||
if (!id) {
|
||
return { code: 400, message: 'id 参数不能为空', data: null };
|
||
}
|
||
|
||
const entryOrder = await ctx.model.EntryOrder.findByPk(id, {
|
||
include: [
|
||
{
|
||
model: ctx.model.EntryItems,
|
||
as: 'items',
|
||
required: false,
|
||
include: [
|
||
{
|
||
model: ctx.model.StockWarehouse,
|
||
as: 'stock',
|
||
attributes: [ 'id', 'item_code', 'item_name', 'sku_property' ],
|
||
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: 404, message: '入库单不存在', data: null };
|
||
}
|
||
|
||
// 校验仓库权限
|
||
if (entryOrder.warehouse_id !== ctx.user.store_id || !entryOrder.is_enabled) {
|
||
return { code: 404, message: '入库单不存在或无权访问', data: null };
|
||
}
|
||
|
||
// 查询货主商家备注
|
||
const storeWarehouse = await ctx.model.StoreWarehouse.findOne({
|
||
where: { store_id: entryOrder.store_id, warehouse_id: entryOrder.warehouse_id },
|
||
attributes: [ 'store_remask' ],
|
||
raw: true,
|
||
});
|
||
|
||
// 查询该入库单下已有的导入/PDA 入库记录(显式过滤软删除,仅统计未删除记录)
|
||
const directLogs = await ctx.model.InboundDirectLog.findAll({
|
||
where: { entry_order_id: entryOrder.id, deleted_at: null },
|
||
order: [[ 'created_at', 'ASC' ]],
|
||
});
|
||
|
||
// 将直接入库记录按 entry_item_id 关联到明细
|
||
// 优先使用 entry_item_id 精确匹配(绑定模式),其次回退到 stock_id 匹配(非绑定模式)
|
||
const itemDirectLogs = {};
|
||
for (const log of directLogs) {
|
||
// 绑定模式下 entry_item_id 已设置,优先用它定位明细行
|
||
const itemByEntryItemId = log.entry_item_id
|
||
? entryOrder.items.find(i => String(i.id) === String(log.entry_item_id))
|
||
: null;
|
||
const item = itemByEntryItemId || entryOrder.items.find(
|
||
i => String(i.stock_id) === String(log.stock_id)
|
||
);
|
||
const key = item ? String(item.id) : `stock_${log.stock_id}`;
|
||
if (!itemDirectLogs[key]) itemDirectLogs[key] = [];
|
||
itemDirectLogs[key].push({
|
||
id: log.id,
|
||
stock_id: log.stock_id,
|
||
quantity: log.quantity,
|
||
inbound_type: log.inbound_type,
|
||
space_id: log.space_id,
|
||
remark: log.remark,
|
||
operator_id: log.operator_id,
|
||
operator_name: log.operator_name,
|
||
created_at: log.created_at,
|
||
});
|
||
}
|
||
|
||
// 将入库单层级的收货单绑定扁平化
|
||
const receivingBindings = (entryOrder.receivingBindings && entryOrder.receivingBindings.length > 0)
|
||
? entryOrder.receivingBindings.map(rb => ({
|
||
id: rb.id,
|
||
receiving_id: rb.receiving_id,
|
||
receiving: rb.receiving || null,
|
||
}))
|
||
: [];
|
||
|
||
// 收集所有 stock_id,通过 getStockDetails 批量获取带缓存的商品详情
|
||
const stockIds = [ ...new Set(
|
||
(entryOrder.items || [])
|
||
.map(item => Number(item.stock_id))
|
||
.filter(sid => sid && sid > 0)
|
||
) ];
|
||
|
||
/** @type {Map<number, Object>} */
|
||
const stockMap = new Map();
|
||
if (stockIds.length > 0) {
|
||
const warehouseId = ctx.user.store_id;
|
||
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId });
|
||
for (const detail of stockDetails) {
|
||
stockMap.set(detail.id, detail);
|
||
}
|
||
}
|
||
|
||
// 组装明细(精简字段,突出已入/总数)
|
||
const items = (entryOrder.items || []).map(item => {
|
||
const planQty = Number(item.count) || 0;
|
||
const logKey = String(item.id);
|
||
const logs = itemDirectLogs[logKey] || [];
|
||
const directInQty = logs.reduce((sum, l) => sum + Number(l.quantity), 0);
|
||
// 优先使用已持久化的 received_quantity(commit 后由系统写入),
|
||
// 若为 0 则回退到 InboundDirectLog 汇总(尚未提交时的导入量),
|
||
// 确保绑定收货明细场景下 completed 口径与 received_quantity 一致。
|
||
const receivedQty = Number(item.received_quantity) || 0;
|
||
const completed = receivedQty > 0 ? receivedQty : directInQty;
|
||
|
||
return {
|
||
id: item.id,
|
||
stock_id: item.stock_id,
|
||
planned: planQty,
|
||
completed,
|
||
stock: stockMap.get(Number(item.stock_id)) || null,
|
||
};
|
||
});
|
||
|
||
// 收集所有 InboundDirectLog 中的 space_id,批量查询库位名称
|
||
/** @type {Map<number, string>} space_id -> space_name */
|
||
const spaceNameMap = new Map();
|
||
const allSpaceIds = [ ...new Set(
|
||
Object.values(itemDirectLogs)
|
||
.flat()
|
||
.map(log => log.space_id)
|
||
.filter(sid => sid != null)
|
||
) ];
|
||
if (allSpaceIds.length > 0) {
|
||
const spaces = await ctx.model.LocationSpace.findAll({
|
||
where: { id: { [app.Sequelize.Op.in]: allSpaceIds } },
|
||
attributes: [ 'id', 'custom_name', 'space_code' ],
|
||
raw: true,
|
||
});
|
||
for (const sp of spaces) {
|
||
spaceNameMap.set(sp.id, sp.custom_name || sp.space_code || '');
|
||
}
|
||
}
|
||
|
||
// 批量查询已绑定的收货明细列表
|
||
const entryItemIds = items.map(i => i.id).filter(Boolean);
|
||
/** @type {Map<number, Array<Object>>} 按 entry_item_id 分组 */
|
||
const bindingsMap = new Map();
|
||
if (entryItemIds.length > 0) {
|
||
const bindingRows = await ctx.model.InboundDirectLog.findAll({
|
||
where: {
|
||
entry_item_id: { [app.Sequelize.Op.in]: entryItemIds },
|
||
receiving_detail_id: { [app.Sequelize.Op.ne]: null },
|
||
deleted_at: null,
|
||
},
|
||
attributes: [ 'id', 'entry_item_id', 'receiving_detail_id', 'quantity', 'status' ],
|
||
raw: true,
|
||
});
|
||
|
||
if (bindingRows.length > 0) {
|
||
const detailIds = [ ...new Set(bindingRows.map(b => b.receiving_detail_id).filter(Boolean)) ];
|
||
const validDetailIds = new Set();
|
||
if (detailIds.length > 0) {
|
||
const details = await ctx.model.ReceivingDetail.findAll({
|
||
where: { id: { [app.Sequelize.Op.in]: detailIds } },
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
});
|
||
for (const d of details) {
|
||
validDetailIds.add(d.id);
|
||
}
|
||
}
|
||
|
||
for (const b of bindingRows) {
|
||
const key = b.entry_item_id;
|
||
if (!bindingsMap.has(key)) {
|
||
bindingsMap.set(key, []);
|
||
}
|
||
bindingsMap.get(key).push({
|
||
detail_id: b.receiving_detail_id,
|
||
binding_id: b.id,
|
||
allocated_quantity: b.quantity || 0,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// 将 bindings 挂到对应 item,并补充库位信息
|
||
for (const item of items) {
|
||
const bindings = bindingsMap.get(item.id) || [];
|
||
const logKey = String(item.id);
|
||
const directLogsForItem = itemDirectLogs[logKey] || [];
|
||
|
||
if (bindings.length === 0 && directLogsForItem.length > 0) {
|
||
const firstWithSpace = directLogsForItem.find(l => l.space_id);
|
||
if (firstWithSpace) {
|
||
item.bindings = [{
|
||
space_id: firstWithSpace.space_id,
|
||
space_name: spaceNameMap.get(Number(firstWithSpace.space_id)) || '',
|
||
}];
|
||
} else {
|
||
item.bindings = [];
|
||
}
|
||
} else {
|
||
const firstWithSpace = directLogsForItem.find(l => l.space_id);
|
||
const sid = firstWithSpace ? firstWithSpace.space_id : null;
|
||
item.bindings = bindings.map(b => ({
|
||
...b,
|
||
space_id: sid,
|
||
space_name: sid != null ? (spaceNameMap.get(Number(sid)) || '') : '',
|
||
}));
|
||
}
|
||
}
|
||
|
||
return {
|
||
code: 200,
|
||
message: '查询成功',
|
||
data: {
|
||
entryOrder: {
|
||
id: entryOrder.id,
|
||
entry_order_code: entryOrder.entry_order_code,
|
||
order_status: entryOrder.order_status,
|
||
store_remask: (storeWarehouse && storeWarehouse.store_remask) || '',
|
||
},
|
||
items,
|
||
receivingBindings,
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 为 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.quantity), 0) AS allocated_quantity,
|
||
rd.actual_quantity - COALESCE(SUM(erb.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_inbound_direct_log 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 {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 addItem(data = {}) {
|
||
const { ctx } = this;
|
||
return await ctx.service.systems.inboundDirectLog.addItem(data);
|
||
}
|
||
|
||
/**
|
||
* 提交确认完成导入/PDA 直接入库(转发到 inboundDirectLog)。
|
||
* @param {string} entryOrderCode 入库单号
|
||
* @return {Promise<Object>} code/data/message 结构
|
||
*/
|
||
async commit(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 removeItem(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(quantity), 0) AS used_qty
|
||
FROM wms_inbound_direct_log
|
||
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_inbound_direct_log 中有记录且未软删除)
|
||
const notBoundCondition = app.Sequelize.literal(
|
||
'NOT EXISTS (SELECT 1 FROM wms_inbound_direct_log 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.InboundDirectLog.findAll({
|
||
attributes: [
|
||
'receiving_detail_id',
|
||
[ app.Sequelize.fn('SUM', app.Sequelize.col('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;
|