liufumingren 3e7c9a7a10 fix: 修复 docs 页面 JS 失效 + 入库 locked_quantity 流水补全 + stock_store 查询条件补全 is_valid
1. docs.js: 修复模板字面量中 '\n' 被服务端解释为换行符导致客户端 JS SyntaxError,所有交互功能失效(搜索/发送按钮)
2. inbound_direct_log.js: batch_no 修正为 effectiveBatchNo;storage 表更新时补全 before_locked_quantity/after_locked_quantity;新增 stock_id 归属校验
3. stock_store.js: 多处查询/更新补全 is_valid='Y' 过滤条件,避免软删除/失效数据泄露或误操作
4. storage/entry.js: 入库完成时补全 storage 表 before_locked_quantity/after_locked_quantity 流水字段
2026-08-09 00:23:42 +08:00

2925 lines
104 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 crypto = require('node:crypto');
const fs = require('node:fs');
const fsp = require('node:fs/promises');
const os = require('node:os');
const path = require('node:path');
const ExcelJS = require('exceljs');
const Service = require('egg').Service;
const { parseWhereConditions } = require('../../../lib/query_condition_parser');
const ENTRY_EXPORT_PAGE_SIZE = 200;
const ENTRY_ITEMS_FETCH_BATCH_SIZE = 100;
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 排序参数
* @param {string} [mode='warehouse'] 查询模式:warehouse=仓库侧(按 warehouse_id 过滤),store=货主侧(按 store_id 过滤)
* @return {Promise<Object>} code/data/message 结构
*/
async list(where = {}, pageParams = {}, sortParams = {}, mode = 'warehouse') {
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 isStoreMode = String(mode).toLowerCase() === 'store';
// 参考 stock.report.search:从 ctx.user.store_id 提取主维度 ID,
// Number(undefined)=NaN(falsy),防止 Sequelize 静默剔除 undefined 键导致过滤失效
const rawPrimaryId = Number(ctx.user && ctx.user.store_id);
const storeId = isStoreMode ? rawPrimaryId : null;
const warehouseId = isStoreMode ? null : rawPrimaryId;
if (isStoreMode && !storeId) {
return {
code: 400,
message: '用户未绑定货主,无法查询货主侧入库单',
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 },
},
};
}
if (!isStoreMode && !warehouseId) {
return {
code: 400,
message: '用户未绑定仓库,无法查询入库单',
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 baseWhere = isStoreMode
? { store_id: storeId, is_enabled: 1, deleted_at: null }
: { warehouse_id: warehouseId, 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,
},
};
}
/**
* 查询入库单详情(与原 storage.directInbound.getItems 输出格式一致)。
* 返回入库单基本信息、商品明细(含计划数量与已完成数量)、收货单绑定关系。
* @param {Object} data 请求参数
* @param {number} data.id 入库单主键 ID(必填)
* @param {string} [mode='warehouse'] 查询维度:'warehouse' 按仓库校验权限(默认),'store' 按货主校验权限
* @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 = {}, mode = 'warehouse') {
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 };
}
const isStoreMode = String(mode).toLowerCase() === 'store';
const rawPrimaryId = Number(ctx.user && ctx.user.store_id);
// 校验权限:仓库模式校验 warehouse_id,货主模式校验 store_id
if (isStoreMode) {
if (entryOrder.store_id !== rawPrimaryId || !entryOrder.is_enabled) {
return { code: 404, message: '入库单不存在或无权访问', data: null };
}
} else {
if (entryOrder.warehouse_id !== rawPrimaryId || !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) {
// 货主模式下传 null 跳过 warehouse 过滤,避免 store_id 误当 warehouse_id 导致查不到商品
const stockWarehouseId = isStoreMode ? null : rawPrimaryId;
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId: stockWarehouseId });
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;
const stockDetail = stockMap.get(Number(item.stock_id));
const stock = stockDetail
? (s => { delete s.quantity; delete s.locked_quantity; return s; })({ ...stockDetail })
: null;
return {
id: item.id,
stock_id: item.stock_id,
planned: planQty,
completed,
stock,
};
});
// 收集所有 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. 查询指定商品的所有收货明细(不再一刀切排除已绑定,改为按可用量过滤)
const details = await ctx.model.ReceivingDetail.findAll({
where: {
system_product_id: stockId,
receiving_id: { [app.Sequelize.Op.in]: receivingIds },
},
raw: true,
});
// 4. 查询每个明细的已入库数量(pending + committed,与 getReceivingDetailsForBind 一致)
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));
}
}
// 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. 组装返回结果:actual_quantity 扣除已入库数量,只返回有可用量的明细
const list = details
.map(detail => {
const used = usedMap.get(detail.id) || 0;
const available = Math.max(0, (detail.actual_quantity || 0) - used);
return {
detail_id: detail.id,
receiving_id: detail.receiving_id,
barcode: detail.barcode || '',
product_name: detail.product_name || '',
actual_quantity: available,
receiving_status: detail.receiving_status || '',
stock: stockDetailMap.get(Number(detail.system_product_id)) || null,
};
})
.filter(detail => detail.actual_quantity > 0);
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) {
throw new Error(`商品库存记录不存在或已失效,无法入库: stock_id=${stockId}`);
}
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;
let storageBeforeLockedQty = 0;
let storageAfterLockedQty = 0;
if (storageRecord) {
storageBeforeQty = Number(storageRecord.quantity) || 0;
storageAfterQty = storageBeforeQty + planQty;
storageBeforeLockedQty = Number(storageRecord.locked_quantity) || 0;
storageAfterLockedQty = storageBeforeLockedQty;
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;
storageBeforeLockedQty = 0;
storageAfterLockedQty = 0;
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,
before_locked_quantity: storageBeforeLockedQty,
after_locked_quantity: storageAfterLockedQty,
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,
},
};
}
/**
* 导出入库单列表及明细(两 Sheet)。
* Sheet1: 入库单列表(wms_entry_order 关键字段)
* Sheet2: 入库单明细(wms_entry_items + wms_stock_warehouse)
*
* @param {Object} options 导出参数
* @param {Object} [options.where] 筛选条件(与 list 一致)
* @param {Object} [options.sort] 排序参数
* @param {Function} [options.onProgress] 进度回调
* @return {Promise<Object>} 上传结果与统计信息
*/
async exportEntryOrders(options = {}) {
const { ctx, app } = this;
const { Sequelize } = app;
const { Op } = Sequelize;
const safeOptions = this.isPlainObject ? (this.isPlainObject(options) ? options : {}) : (options && typeof options === 'object' ? options : {});
const where = safeOptions.where && typeof safeOptions.where === 'object' ? { ...safeOptions.where } : {};
const sort = safeOptions.sort && typeof safeOptions.sort === 'object' ? { ...safeOptions.sort } : {};
const progressHandler = typeof safeOptions.onProgress === 'function'
? safeOptions.onProgress
: async () => {};
const warehouseId = Number(ctx.user && ctx.user.store_id);
if (!warehouseId) {
throw new Error('用户未绑定仓库,无法导出');
}
const sortField = sort.sortField || 'created_at';
const sortOrder = String(sort.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: warehouseId, is_enabled: 1, deleted_at: null };
// ---- 复用 list 的 where 构建逻辑 ----
const normalizedWhere = { ...where };
const {
where: parsedSourceWhere,
extraConditions,
errorMessage,
} = await this.preprocessEntryListWhere(normalizedWhere);
if (errorMessage) {
throw new Error(errorMessage);
}
const parsed = parseWhereConditions({
where: parsedSourceWhere,
app,
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
if (!parsed.ok) {
throw new Error(`筛选条件解析失败: ${parsed.reason}`);
}
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}%` } },
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),
...(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 pageSize = ENTRY_EXPORT_PAGE_SIZE;
const totalCount = await ctx.model.EntryOrder.count({ where: finalWhere });
await progressHandler({
status: 'running',
progress: totalCount > 0 ? 10 : 90,
message: totalCount > 0 ? `已命中 ${totalCount} 条入库单,开始导出` : '未命中数据,开始生成空文件',
});
// 收集所有入库单 ID,供后续批量查明细
const allEntryOrders = [];
let page = 1;
let fetchedCount = 0;
while (fetchedCount < totalCount) {
const rows = await ctx.model.EntryOrder.findAll({
where: finalWhere,
order: [[ actualSortField, sortOrder ]],
limit: pageSize,
offset: (page - 1) * pageSize,
raw: true,
});
if (!Array.isArray(rows) || rows.length === 0) {
break;
}
allEntryOrders.push(...rows);
fetchedCount += rows.length;
page += 1;
await progressHandler({
status: 'running',
progress: Math.min(30, 10 + Math.round((fetchedCount / Math.max(totalCount, 1)) * 20)),
message: `正在拉取入库单列表,已完成 ${fetchedCount}/${totalCount}`,
});
}
// 收集所有入库单 ID
const allEntryOrderIds = allEntryOrders.map(r => Number(r.id)).filter(Boolean);
// ---- 分批拉取入库单明细 ----
/** @type {Map<number, Array<Object>>} entry_order_id → items */
const itemsMap = new Map();
/** @type {Set<number>} 所有涉及的商品 stock_id */
const allStockIds = new Set();
if (allEntryOrderIds.length > 0) {
const batchSize = ENTRY_ITEMS_FETCH_BATCH_SIZE;
const totalBatches = Math.ceil(allEntryOrderIds.length / batchSize);
for (let batchIdx = 0; batchIdx < allEntryOrderIds.length; batchIdx += batchSize) {
const batchIds = allEntryOrderIds.slice(batchIdx, batchIdx + batchSize);
const items = await ctx.model.EntryItems.findAll({
where: { order_id: { [Op.in]: batchIds } },
order: [[ 'order_id', 'ASC' ], [ 'order_line_no', 'ASC' ]],
raw: true,
});
for (const item of items) {
const eid = Number(item.order_id);
if (!itemsMap.has(eid)) {
itemsMap.set(eid, []);
}
itemsMap.get(eid).push(item);
if (item.stock_id) {
allStockIds.add(Number(item.stock_id));
}
}
const currentBatch = Math.floor(batchIdx / batchSize) + 1;
await progressHandler({
status: 'running',
progress: Math.min(50, 30 + Math.round((currentBatch / totalBatches) * 20)),
message: `正在拉取入库单明细,已完成批次 ${currentBatch}/${totalBatches}`,
});
}
}
// ---- 批量查询商品名称(wms_stock_warehouse) ----
/** @type {Map<number, Object>} stock_id → { item_name, sku_property, item_code } */
const stockInfoMap = new Map();
if (allStockIds.size > 0) {
const stockIdsArr = [ ...allStockIds ];
try {
const stockRows = await ctx.model.StockWarehouse.findAll({
where: { id: { [Op.in]: stockIdsArr }, warehouse_id: warehouseId },
attributes: [ 'id', 'item_code', 'item_name', 'sku_property' ],
raw: true,
});
for (const s of stockRows) {
stockInfoMap.set(Number(s.id), {
item_code: s.item_code || '',
item_name: s.item_name || '',
sku_property: s.sku_property || '',
});
}
} catch (err) {
ctx.logger.warn(`[exportEntryOrders] 批量查询商品信息失败: ${err.message}`);
}
}
await progressHandler({
status: 'running',
progress: 55,
message: '正在生成 Excel 文件...',
});
// ---- 生成 Excel(流式写入,两个 Sheet) ----
const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'wms-entry-export-'));
const now = new Date();
const dateToken = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}`;
const filename = `入库单导出_${dateToken}.xlsx`;
const filePath = path.join(tempDir, filename);
const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({
filename: filePath,
useStyles: false,
useSharedStrings: false,
});
// Sheet 1: 入库单列表
const sheet1 = workbook.addWorksheet('入库单列表');
const entryOrderColumns = [
{ header: '入库单号', key: 'entry_order_code', width: 22 },
{ header: '业务类型', key: 'order_type', width: 10 },
{ header: '采购单号', key: 'purchase_order_code', width: 22 },
{ header: '订单状态', key: 'order_status', width: 12 },
{ header: '供应商编码', key: 'supplier_code', width: 16 },
{ header: '供应商名称', key: 'supplier_name', width: 24 },
{ header: '物流公司', key: 'logistics_name', width: 20 },
{ header: '运单号', key: 'express_code', width: 22 },
{ header: '货主', key: 'store_name', width: 24 },
{ header: '仓库', key: 'warehouse_name', width: 24 },
{ header: '总行数', key: 'total_order_lines', width: 10 },
{ header: '来源类型', key: 'source_type', width: 10 },
{ header: '状态', key: 'sync_status', width: 12 },
{ header: 'ERP备注', key: 'remark', width: 30 },
{ header: '费用记录', key: 'expense_record', width: 10 },
{ header: '预期到货时间', key: 'expect_start_time', width: 20 },
{ header: '最迟预期到货时间', key: 'expect_end_time', width: 20 },
{ header: '订单创建时间', key: 'order_create_time', width: 20 },
{ header: '创建时间', key: 'created_at', width: 20 },
{ header: '更新时间', key: 'updated_at', width: 20 },
];
sheet1.columns = entryOrderColumns;
const statusLabelMap = {
CREATING: '创建中',
CREATED: '已创建',
PENDING: '已审核',
COMPLETED: '已完成',
CANCELLED: '已作废',
};
const syncStatusLabelMap = {
PENDING: '待同步',
SUCCESS: '成功',
FAILED: '失败',
};
const normalizeCellValue = value => {
if (value === null || value === undefined) return '';
if (value instanceof Date) return app.formatDate ? app.formatDate(value) : value.toISOString();
return value;
};
const orderTypeLabelMap = {
SCRK: '收货入库',
LYRK: '领用入库',
CCRK: '残次入库',
CGRK: '采购入库',
DBRK: '调拨入库',
QTRK: '其他入库',
B2BRK: 'B2B入库',
XNRK: '虚拟入库',
SHRK: '损耗入库',
};
for (const row of allEntryOrders) {
sheet1.addRow({
entry_order_code: normalizeCellValue(row.entry_order_code),
order_type: orderTypeLabelMap[row.order_type] || row.order_type || '',
purchase_order_code: normalizeCellValue(row.purchase_order_code),
order_status: statusLabelMap[row.order_status] || row.order_status || '',
supplier_code: normalizeCellValue(row.supplier_code),
supplier_name: normalizeCellValue(row.supplier_name),
logistics_name: normalizeCellValue(row.logistics_name),
express_code: normalizeCellValue(row.express_code),
store_name: normalizeCellValue(row.store_name),
warehouse_name: normalizeCellValue(row.warehouse_name),
total_order_lines: row.total_order_lines,
source_type: normalizeCellValue(row.source_type),
sync_status: syncStatusLabelMap[row.sync_status] || row.sync_status || '',
remark: normalizeCellValue(row.remark),
expense_record: row.expense_record === 1 ? '是' : (row.expense_record === 0 ? '否' : ''),
expect_start_time: normalizeCellValue(row.expect_start_time),
expect_end_time: normalizeCellValue(row.expect_end_time),
order_create_time: normalizeCellValue(row.order_create_time),
created_at: normalizeCellValue(row.created_at),
updated_at: normalizeCellValue(row.updated_at),
}).commit();
}
sheet1.commit();
await progressHandler({
status: 'running',
progress: 70,
message: '正在写入入库单明细...',
});
// Sheet 2: 入库单明细
const sheet2 = workbook.addWorksheet('入库单明细');
const entryItemColumns = [
{ header: '入库单号', key: 'entry_order_code', width: 22 },
{ header: '入库单ID', key: 'entry_order_id', width: 12 },
{ header: '行号', key: 'order_line_no', width: 8 },
{ header: '商品编码', key: 'item_code', width: 20 },
{ header: '商品名称', key: 'item_name', width: 28 },
{ header: '商品规格', key: 'sku_property', width: 24 },
{ header: '计划入库数量', key: 'plan_quantity', width: 14 },
{ header: '已收货数量', key: 'received_quantity', width: 14 },
{ header: '已通知数量', key: 'confirm_quantity', width: 14 },
{ header: '库存类型', key: 'inventory_type', width: 14 },
{ header: '外部业务编码', key: 'out_biz_code', width: 24 },
{ header: '货主编码', key: 'owner_code', width: 16 },
{ header: '商品ID', key: 'item_id', width: 12 },
{ header: '商品SKU ID', key: 'stock_id', width: 12 },
];
sheet2.columns = entryItemColumns;
// 构建 entry_order_code 映射
const entryOrderCodeMap = new Map();
for (const row of allEntryOrders) {
entryOrderCodeMap.set(Number(row.id), row.entry_order_code || '');
}
// 按入库单分页写入明细
const itemBatchSize = ENTRY_ITEMS_FETCH_BATCH_SIZE;
let itemWrittenCount = 0;
const totalEntryOrders = allEntryOrderIds.length;
for (let batchIdx = 0; batchIdx < allEntryOrderIds.length; batchIdx += itemBatchSize) {
const batchIds = allEntryOrderIds.slice(batchIdx, batchIdx + itemBatchSize);
for (const eid of batchIds) {
const entryOrderCode = entryOrderCodeMap.get(eid) || '';
const items = itemsMap.get(eid) || [];
for (const item of items) {
const stockId = Number(item.stock_id || 0);
const stockInfo = stockInfoMap.get(stockId) || {};
sheet2.addRow({
entry_order_code: entryOrderCode,
entry_order_id: eid,
order_line_no: item.order_line_no ?? '',
item_code: stockInfo.item_code || item.item_code || '',
item_name: stockInfo.item_name || '',
sku_property: stockInfo.sku_property || '',
plan_quantity: item.count ?? 0,
received_quantity: item.received_quantity ?? 0,
confirm_quantity: item.confirm_quantity ?? 0,
inventory_type: normalizeCellValue(item.inventory_type),
out_biz_code: normalizeCellValue(item.out_biz_code),
owner_code: normalizeCellValue(item.owner_code),
item_id: normalizeCellValue(item.item_id),
stock_id: item.stock_id ?? '',
}).commit();
}
itemWrittenCount += 1;
}
const currentBatch = Math.floor(batchIdx / itemBatchSize) + 1;
const totalBatches = Math.ceil(totalEntryOrders / itemBatchSize);
await progressHandler({
status: 'running',
progress: Math.min(90, 70 + Math.round((currentBatch / totalBatches) * 20)),
message: `正在写入入库单明细,已完成 ${itemWrittenCount}/${totalEntryOrders} 条入库单`,
});
}
sheet2.commit();
await workbook.commit();
await progressHandler({
status: 'running',
progress: 92,
message: '正在上传文件...',
});
// ---- 上传文件 ----
const uploadService = ctx?.service?.systems?.upload;
if (!uploadService || typeof uploadService.uploadFile !== 'function') {
throw new Error('上传服务不可用');
}
const stat = await fsp.stat(filePath);
const randomToken = crypto.randomBytes(6).toString('hex');
const uploadKey = `exports/entry/${warehouseId}/${Date.now()}_${randomToken}.xlsx`;
const uploadStream = fs.createReadStream(filePath);
uploadStream.filename = filename;
uploadStream.mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
uploadStream.fileSize = stat.size;
const uploadResult = await uploadService.uploadFile(uploadStream, {
key: uploadKey,
category: 'document',
mimetype: 'xls,xlsx,csv',
});
let fileRecord = null;
if (typeof uploadService.uploadSuccessNotify === 'function') {
fileRecord = await uploadService.uploadSuccessNotify({
url: uploadResult.fileName,
fileKey: uploadResult.fileName,
fileName: filename,
fileType: 'document',
mimeType: uploadStream.mimeType,
fileSize: stat.size,
category: 'document',
businessType: 'entryExport',
businessId: `${warehouseId}`,
uploaderType: ctx?.user?.role || 'system_api',
uploaderDept: ctx?.user?.department || '',
});
}
const result = {
filename,
fileKey: uploadResult.fileName,
url: uploadResult.url || uploadResult.cdnUrl || uploadResult.cosUrl || '',
cdnUrl: uploadResult.cdnUrl || uploadResult.url || '',
cosUrl: uploadResult.cosUrl || '',
total_count: totalCount,
fileRecord: fileRecord?.data || fileRecord || null,
};
// 清理临时目录
await fsp.rm(tempDir, { recursive: true, force: true });
await progressHandler({
status: 'success',
progress: 100,
message: '导出完成',
result,
});
return result;
}
/**
* 导出货主侧入库单列表(双 sheet:入库单列表 + 入库单明细)。
* 复用 list 的筛选与排序语义,以货主维度(store_id)过滤,分页拉取全量数据后生成 Excel 并上传。
* @param {Object} options 导出选项
* @param {Object} [options.where] 筛选条件(与 listStore 一致)
* @param {Object} [options.sort] 排序参数
* @param {Function} [options.onProgress] 进度回调
* @return {Promise<Object>} 上传结果与统计信息
*/
async exportStoreEntryOrders(options = {}) {
const { ctx, app } = this;
const { Sequelize } = app;
const { Op } = Sequelize;
const safeOptions = options && typeof options === 'object' ? options : {};
const where = safeOptions.where && typeof safeOptions.where === 'object' ? { ...safeOptions.where } : {};
const sort = safeOptions.sort && typeof safeOptions.sort === 'object' ? { ...safeOptions.sort } : {};
const progressHandler = typeof safeOptions.onProgress === 'function'
? safeOptions.onProgress
: async () => {};
const storeId = Number(ctx.user && ctx.user.store_id);
if (!storeId) {
throw new Error('用户未绑定货主,无法导出');
}
const sortField = sort.sortField || 'created_at';
const sortOrder = String(sort.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 = { store_id: storeId, is_enabled: 1, deleted_at: null };
// ---- 复用 listStore 的 where 构建逻辑 ----
const normalizedWhere = { ...where };
const {
where: parsedSourceWhere,
extraConditions,
errorMessage,
} = await this.preprocessEntryListWhere(normalizedWhere);
if (errorMessage) {
throw new Error(errorMessage);
}
const parsed = parseWhereConditions({
where: parsedSourceWhere,
app,
specialFieldMap: {
quickWhere: { bucket: 'quick' },
},
});
if (!parsed.ok) {
throw new Error(`筛选条件解析失败: ${parsed.reason}`);
}
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}%` } },
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),
...(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 pageSize = ENTRY_EXPORT_PAGE_SIZE;
const totalCount = await ctx.model.EntryOrder.count({ where: finalWhere });
await progressHandler({
status: 'running',
progress: totalCount > 0 ? 10 : 90,
message: totalCount > 0 ? `已命中 ${totalCount} 条货主侧入库单,开始导出` : '未命中数据,开始生成空文件',
});
const allEntryOrders = [];
let page = 1;
let fetchedCount = 0;
while (fetchedCount < totalCount) {
const rows = await ctx.model.EntryOrder.findAll({
where: finalWhere,
order: [[ actualSortField, sortOrder ]],
limit: pageSize,
offset: (page - 1) * pageSize,
raw: true,
});
if (!Array.isArray(rows) || rows.length === 0) {
break;
}
allEntryOrders.push(...rows);
fetchedCount += rows.length;
page += 1;
await progressHandler({
status: 'running',
progress: Math.min(30, 10 + Math.round((fetchedCount / Math.max(totalCount, 1)) * 20)),
message: `正在拉取货主侧入库单列表,已完成 ${fetchedCount}/${totalCount}`,
});
}
const allEntryOrderIds = allEntryOrders.map(r => Number(r.id)).filter(Boolean);
// ---- 分批拉取入库单明细 ----
/** @type {Map<number, Array<Object>>} */
const itemsMap = new Map();
/** @type {Set<number>} */
const allStockIds = new Set();
if (allEntryOrderIds.length > 0) {
const batchSize = ENTRY_ITEMS_FETCH_BATCH_SIZE;
const totalBatches = Math.ceil(allEntryOrderIds.length / batchSize);
for (let batchIdx = 0; batchIdx < allEntryOrderIds.length; batchIdx += batchSize) {
const batchIds = allEntryOrderIds.slice(batchIdx, batchIdx + batchSize);
const items = await ctx.model.EntryItems.findAll({
where: { order_id: { [Op.in]: batchIds } },
order: [[ 'order_id', 'ASC' ], [ 'order_line_no', 'ASC' ]],
raw: true,
});
for (const item of items) {
const eid = Number(item.order_id);
if (!itemsMap.has(eid)) {
itemsMap.set(eid, []);
}
itemsMap.get(eid).push(item);
if (item.stock_id) {
allStockIds.add(Number(item.stock_id));
}
}
const currentBatch = Math.floor(batchIdx / batchSize) + 1;
await progressHandler({
status: 'running',
progress: Math.min(50, 30 + Math.round((currentBatch / totalBatches) * 20)),
message: `正在拉取货主侧入库单明细,已完成批次 ${currentBatch}/${totalBatches}`,
});
}
}
// ---- 批量查询商品名称(按 store_id) ----
/** @type {Map<number, Object>} */
const stockInfoMap = new Map();
if (allStockIds.size > 0) {
const stockIdsArr = [ ...allStockIds ];
try {
const stockRows = await ctx.model.StockWarehouse.findAll({
where: { id: { [Op.in]: stockIdsArr }, store_id: storeId },
attributes: [ 'id', 'item_code', 'item_name', 'sku_property' ],
raw: true,
});
for (const s of stockRows) {
stockInfoMap.set(Number(s.id), {
item_code: s.item_code || '',
item_name: s.item_name || '',
sku_property: s.sku_property || '',
});
}
} catch (err) {
ctx.logger.warn(`[exportStoreEntryOrders] 批量查询商品信息失败: ${err.message}`);
}
}
await progressHandler({
status: 'running',
progress: 55,
message: '正在生成 Excel 文件...',
});
// ---- 生成 Excel ----
const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'wms-store-entry-export-'));
const now = new Date();
const dateToken = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}`;
const filename = `货主侧入库单导出_${dateToken}.xlsx`;
const filePath = path.join(tempDir, filename);
const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({
filename: filePath,
useStyles: false,
useSharedStrings: false,
});
const normalizeCellValue = value => {
if (value === null || value === undefined) return '';
if (value instanceof Date) return app.formatDate ? app.formatDate(value) : value.toISOString();
return value;
};
const statusLabelMap = {
CREATING: '创建中',
CREATED: '已创建',
PENDING: '已审核',
COMPLETED: '已完成',
CANCELLED: '已作废',
};
const syncStatusLabelMap = {
PENDING: '待同步',
SUCCESS: '成功',
FAILED: '失败',
};
const orderTypeLabelMap = {
SCRK: '收货入库',
LYRK: '领用入库',
CCRK: '残次入库',
CGRK: '采购入库',
DBRK: '调拨入库',
QTRK: '其他入库',
B2BRK: 'B2B入库',
XNRK: '虚拟入库',
SHRK: '损耗入库',
};
// Sheet 1: 入库单列表(货主侧,不显示仓库字段)
const sheet1 = workbook.addWorksheet('入库单列表');
const entryOrderColumns = [
{ header: '入库单号', key: 'entry_order_code', width: 22 },
{ header: '业务类型', key: 'order_type', width: 10 },
{ header: '采购单号', key: 'purchase_order_code', width: 22 },
{ header: '订单状态', key: 'order_status', width: 12 },
{ header: '供应商编码', key: 'supplier_code', width: 16 },
{ header: '供应商名称', key: 'supplier_name', width: 24 },
{ header: '物流公司', key: 'logistics_name', width: 20 },
{ header: '运单号', key: 'express_code', width: 22 },
{ header: '仓库', key: 'warehouse_name', width: 24 },
{ header: '总行数', key: 'total_order_lines', width: 10 },
{ header: '来源类型', key: 'source_type', width: 10 },
{ header: '状态', key: 'sync_status', width: 12 },
{ header: 'ERP备注', key: 'remark', width: 30 },
{ header: '费用记录', key: 'expense_record', width: 10 },
{ header: '预期到货时间', key: 'expect_start_time', width: 20 },
{ header: '最迟预期到货时间', key: 'expect_end_time', width: 20 },
{ header: '订单创建时间', key: 'order_create_time', width: 20 },
{ header: '创建时间', key: 'created_at', width: 20 },
{ header: '更新时间', key: 'updated_at', width: 20 },
];
sheet1.columns = entryOrderColumns;
for (const row of allEntryOrders) {
sheet1.addRow({
entry_order_code: normalizeCellValue(row.entry_order_code),
order_type: orderTypeLabelMap[row.order_type] || row.order_type || '',
purchase_order_code: normalizeCellValue(row.purchase_order_code),
order_status: statusLabelMap[row.order_status] || row.order_status || '',
supplier_code: normalizeCellValue(row.supplier_code),
supplier_name: normalizeCellValue(row.supplier_name),
logistics_name: normalizeCellValue(row.logistics_name),
express_code: normalizeCellValue(row.express_code),
warehouse_name: normalizeCellValue(row.warehouse_name),
total_order_lines: row.total_order_lines,
source_type: normalizeCellValue(row.source_type),
sync_status: syncStatusLabelMap[row.sync_status] || row.sync_status || '',
remark: normalizeCellValue(row.remark),
expense_record: row.expense_record === 1 ? '是' : (row.expense_record === 0 ? '否' : ''),
expect_start_time: normalizeCellValue(row.expect_start_time),
expect_end_time: normalizeCellValue(row.expect_end_time),
order_create_time: normalizeCellValue(row.order_create_time),
created_at: normalizeCellValue(row.created_at),
updated_at: normalizeCellValue(row.updated_at),
}).commit();
}
sheet1.commit();
await progressHandler({
status: 'running',
progress: 70,
message: '正在写入入库单明细...',
});
// Sheet 2: 入库单明细
const sheet2 = workbook.addWorksheet('入库单明细');
const entryItemColumns = [
{ header: '入库单号', key: 'entry_order_code', width: 22 },
{ header: '入库单ID', key: 'entry_order_id', width: 12 },
{ header: '行号', key: 'order_line_no', width: 8 },
{ header: '商品编码', key: 'item_code', width: 20 },
{ header: '商品名称', key: 'item_name', width: 28 },
{ header: '商品规格', key: 'sku_property', width: 24 },
{ header: '计划入库数量', key: 'plan_quantity', width: 14 },
{ header: '已收货数量', key: 'received_quantity', width: 14 },
{ header: '已通知数量', key: 'confirm_quantity', width: 14 },
{ header: '库存类型', key: 'inventory_type', width: 14 },
{ header: '外部业务编码', key: 'out_biz_code', width: 24 },
{ header: '货主编码', key: 'owner_code', width: 16 },
{ header: '商品ID', key: 'item_id', width: 12 },
{ header: '商品SKU ID', key: 'stock_id', width: 12 },
];
sheet2.columns = entryItemColumns;
const entryOrderCodeMap = new Map();
for (const row of allEntryOrders) {
entryOrderCodeMap.set(Number(row.id), row.entry_order_code || '');
}
const itemBatchSize = ENTRY_ITEMS_FETCH_BATCH_SIZE;
let itemWrittenCount = 0;
const totalEntryOrders = allEntryOrderIds.length;
for (let batchIdx = 0; batchIdx < allEntryOrderIds.length; batchIdx += itemBatchSize) {
const batchIds = allEntryOrderIds.slice(batchIdx, batchIdx + itemBatchSize);
for (const eid of batchIds) {
const entryOrderCode = entryOrderCodeMap.get(eid) || '';
const items = itemsMap.get(eid) || [];
for (const item of items) {
const stockId = Number(item.stock_id || 0);
const stockInfo = stockInfoMap.get(stockId) || {};
sheet2.addRow({
entry_order_code: entryOrderCode,
entry_order_id: eid,
order_line_no: item.order_line_no ?? '',
item_code: stockInfo.item_code || item.item_code || '',
item_name: stockInfo.item_name || '',
sku_property: stockInfo.sku_property || '',
plan_quantity: item.count ?? 0,
received_quantity: item.received_quantity ?? 0,
confirm_quantity: item.confirm_quantity ?? 0,
inventory_type: normalizeCellValue(item.inventory_type),
out_biz_code: normalizeCellValue(item.out_biz_code),
owner_code: normalizeCellValue(item.owner_code),
item_id: normalizeCellValue(item.item_id),
stock_id: item.stock_id ?? '',
}).commit();
}
itemWrittenCount += 1;
}
const currentBatch = Math.floor(batchIdx / itemBatchSize) + 1;
const totalBatches = Math.ceil(totalEntryOrders / itemBatchSize);
await progressHandler({
status: 'running',
progress: Math.min(90, 70 + Math.round((currentBatch / totalBatches) * 20)),
message: `正在写入入库单明细,已完成 ${itemWrittenCount}/${totalEntryOrders} 条入库单`,
});
}
sheet2.commit();
await workbook.commit();
await progressHandler({
status: 'running',
progress: 92,
message: '正在上传文件...',
});
// ---- 上传文件 ----
const uploadService = ctx?.service?.systems?.upload;
if (!uploadService || typeof uploadService.uploadFile !== 'function') {
throw new Error('上传服务不可用');
}
const stat = await fsp.stat(filePath);
const randomToken = crypto.randomBytes(6).toString('hex');
const uploadKey = `exports/entry/store/${storeId}/${Date.now()}_${randomToken}.xlsx`;
const uploadStream = fs.createReadStream(filePath);
uploadStream.filename = filename;
uploadStream.mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
uploadStream.fileSize = stat.size;
const uploadResult = await uploadService.uploadFile(uploadStream, {
key: uploadKey,
category: 'document',
mimetype: 'xls,xlsx,csv',
});
let fileRecord = null;
if (typeof uploadService.uploadSuccessNotify === 'function') {
fileRecord = await uploadService.uploadSuccessNotify({
url: uploadResult.fileName,
fileKey: uploadResult.fileName,
fileName: filename,
fileType: 'document',
mimeType: uploadStream.mimeType,
fileSize: stat.size,
userId: ctx.userId,
description: `货主侧入库单导出(货主${storeId}),共${totalCount}条入库单`,
});
}
// 清理临时文件
try { await fsp.rm(tempDir, { recursive: true, force: true }); } catch (_) { /* ignore */ }
const uploadInfo = fileRecord || uploadResult;
const fileUrl = typeof uploadInfo === 'object' && uploadInfo.url
? uploadInfo.url
: (typeof uploadResult === 'object' ? uploadResult.fileName : '');
await progressHandler({
status: 'running',
progress: 100,
message: '货主侧导出完成',
result: { url: fileUrl, fileKey: uploadKey },
});
return {
url: fileUrl,
fileKey: uploadKey,
total: totalCount,
totalDetails: allEntryOrderIds.reduce((sum, eid) => sum + (itemsMap.get(eid) || []).length, 0),
};
}
}
module.exports = EntryService;