liufumingren 7f05b26db2 1
2026-07-04 21:40:31 +08:00

384 lines
14 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 MainService = require('../../main');
/**
* 系统方法层:storage.entry(入库单相关接口包装层)。
* 主要职责:统一包装系统方法接口,处理权限、日志等公共逻辑,调用底层 service 实现业务功能。
* 注意:当前实现仅为包装层,实际业务逻辑完全依赖底层 service 的方法实现。
*/
class entryService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'list,get,cancel,getPrintData,getDirectInboundItems,addItem,commit,removeItem,quickInbound,receivingCompare,queryEntryLogs,getReceivingDetailsForBind,reviewEntry,containerList';
const _noNeedLog = 'list,get,getPrintData,reviewEntry,containerList';
const _noNeedAuth = 'list,get,cancel,getPrintData,getDirectInboundItems,addItem,commit,removeItem,bindReceiving,quickInbound,receivingCompare,unbindReceiving,queryEntryLogs,getReceivingDetailsForBind,reviewEntry,containerList';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 入库单列表查询。
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.where] 动态筛选条件
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装
*/
async list(data = {}) {
const { service } = this;
const { pagination, sort } = data;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const result = await service.systems.storage.entry.list(where, pagination, sort);
return this.success('ok', result);
}
/**
* 查询入库单详情(与原 storage.directInbound.getItems 输出格式一致)。
* 返回入库单基本信息(id、entry_order_code、order_status、store_remask)、
* 商品明细列表(含计划数量、已完成入库数量、商品信息、收货单绑定明细),
* 以及收货单绑定关系列表。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID(必填)
* @return {Promise<Object>} 统一 success 包装
*/
async get(data = {}) {
const { service } = this;
const { id } = data || {};
const result = await service.systems.storage.entry.get({ id });
return this.success('ok', result);
}
/**
* 作废入库单。
* 支持传入单个 id 或批量 ids,保持透传给业务层处理。
* @param {Object} data 请求体
* @param {number} [data.id] 单个入库单ID
* @param {number[]} [data.ids] 批量入库单ID数组
* @return {Promise<Object>} 统一 success 包装
*/
async cancel(data = {}) {
const { service } = this;
const result = await service.systems.storage.entry.cancel(data);
return this.success('ok', result);
}
/**
* 按商品增量添加导入/PDA 直接入库记录(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} [data.stock_id] 商品SKU ID(单条模式)
* @param {number} [data.quantity] 本次入库数量(单条模式)
* @param {string} [data.inbound_type] 入库方式(单条模式)
* @param {Array} [data.items] 商品列表(批量模式)
* @param {string} [data.remark] 备注(单条模式)
* @param {number} [data.space_id] 库位ID(单条模式)
* @param {number} [data.receiving_detail_id] 收货单明细ID(单条模式,可选)
* @param {number} [data.allocated_quantity] 预分配数量(单条模式,可选)
* @return {Promise<Object>} 统一 success 包装
*/
async addItem(data = {}) {
const { service } = this;
const {
entry_order_id,
stock_id,
quantity,
inbound_type,
items,
remark,
space_id,
receiving_detail_id,
allocated_quantity,
} = data || {};
const result = await service.systems.inboundDirectLog.addItem({
entry_order_id,
stock_id,
quantity,
inbound_type,
items,
remark,
space_id,
receiving_detail_id,
allocated_quantity,
});
return this.success('ok', result);
}
/**
* 提交确认完成导入/PDA 直接入库(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @return {Promise<Object>} 统一 success 包装
*/
async commit(data = {}) {
const { service } = this;
const { entry_order_id } = data || {};
const result = await service.systems.inboundDirectLog.commit(entry_order_id);
return this.success('ok', result);
}
/**
* 移除一条导入/PDA 直接入库记录(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.id 入库记录ID
* @return {Promise<Object>} 统一 success 包装
*/
async removeItem(data = {}) {
const { service } = this;
const result = await service.systems.inboundDirectLog.removeItem(data);
return this.success('ok', result);
}
/**
* 绑定入库单与收货单的主表关系(仅主表绑定,不做明细分配)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @param {number[]} data.receiving_ids 收货单 ID 列表
* @return {Promise<Object>} 统一 success 包装
*/
async bindReceiving(data = {}) {
const { ctx } = this;
console.log('[DEBUG] systems keys:', Object.keys(ctx.service.systems));
console.log('[DEBUG] receiving_entry_match:', typeof ctx.service.systems.receivingEntryMatch);
const { entry_order_id, receiving_ids } = data || {};
const creator_id = ctx.user ? ctx.user.id || ctx.user.user_id : undefined;
const result = await ctx.service.systems.receivingEntryMatch.bindEntryOrderReceiving({
entry_order_id,
receiving_ids,
creator_id,
});
return this.success('绑定完成', result);
}
/**
* 解除入库单与收货单的绑定关系。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @param {number[]} data.receiving_ids 要解除绑定的收货单 ID 列表
* @return {Promise<Object>} 统一 success 包装
*/
async unbindReceiving(data = {}) {
const { ctx } = this;
const { entry_order_id, receiving_ids } = data || {};
const result = await ctx.service.systems.receivingEntryMatch.unbindEntryOrderReceiving({
entry_order_id,
receiving_ids,
});
return this.success('解绑完成', result);
}
/**
* 快捷直入/虚拟入库(system method 包装层)。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @return {Promise<Object>} 统一 success 包装
*/
async quickInbound(data = {}) {
const { service } = this;
const { id } = data;
const result = await service.systems.storage.entry.quickInbound({ id });
if (result && result.code === 200) {
return this.success(result.message || 'ok', result);
}
return this.fail(result?.message || '快捷入库失败', result);
}
/**
* 获取入库单打印数据,按 RECEIPT 模板 field_code 映射返回。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @param {number} [data.warehouse_id] 仓库ID,不传则取当前用户仓库
* @return {Promise<Object>} 打印数据(扁平键值 + items 明细数组)
*/
async getPrintData(data = {}) {
const { ctx } = this;
const id = Number(data && data.id || 0);
if (!id) {
return this.fail('id 参数不能为空', { code: 400 });
}
try {
// 直接查询入库单完整信息(含 items、warehouse、store 等关联),供打印模板使用
const entryOrder = await ctx.model.EntryOrder.findByPk(id, {
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.Store,
as: 'store',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.EntryItems,
as: 'items',
required: false,
},
],
});
if (!entryOrder || entryOrder.warehouse_id !== ctx.user.store_id || !entryOrder.is_enabled) {
return this.fail('入库单不存在', { code: 404 });
}
const entryOrderJSON = entryOrder.toJSON();
const items = Array.isArray(entryOrderJSON.items) ? entryOrderJSON.items : [];
// 查询商品条码和图片(复用 getStockDetails 缓存)
const barcodeMap = new Map();
const imageMap = new Map();
try {
const stockIds = items
.map(item => Number(item.stock_id || 0))
.filter(sid => sid > 0);
if (stockIds.length > 0) {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{}
);
for (const detail of stockDetails) {
const sid = Number(detail.id);
// 提取条码
if (Array.isArray(detail.barcodes) && detail.barcodes.length > 0) {
barcodeMap.set(
sid,
detail.barcodes.map(bc => String(bc.barcode || '').trim()).filter(Boolean)
);
}
// 提取图片(有图片标记但实际 URL 需要额外查询)
if (detail.is_images === 'Y') {
imageMap.set(sid, '');
}
}
}
} catch (err) {
ctx.logger.warn('[entry.getPrintData] 查询商品详情失败: %s', err.message);
}
const printData = {
entry_order_code: entryOrderJSON.entry_order_code || '',
order_type: entryOrderJSON.order_type || '',
order_status: entryOrderJSON.order_status || '',
purchase_order_code: entryOrderJSON.purchase_order_code || '',
supplier_name: entryOrderJSON.supplier_name || '',
warehouse_name: entryOrderJSON.warehouse_name || '',
store_name: entryOrderJSON.store_name || '',
logistics_name: entryOrderJSON.logistics_name || '',
express_code: entryOrderJSON.express_code || '',
order_create_time: entryOrderJSON.order_create_time || '',
expect_start_time: entryOrderJSON.expect_start_time || '',
remark: entryOrderJSON.remark || '',
total_order_lines: entryOrderJSON.total_order_lines || 0,
items: items.map(item => ({
items_col1: item.item_code || '',
items_col2: '',
items_col3: (barcodeMap.get(Number(item.stock_id)) || []).join(';') || '',
items_col4: item.count || 0,
items_col5: item.received_quantity || 0,
items_col6: item.inventory_type || '',
items_col7: imageMap.get(Number(item.stock_id)) || '',
})),
};
return this.success('ok', { data: printData, code: 200 });
} catch (error) {
ctx.logger.error('[entry.getPrintData] 获取入库单打印数据失败:', error);
return this.fail(error.message || '获取打印数据失败', { code: 500 });
}
}
/**
* 入库单商品与收货单商品逐行对照视图(system method 包装层)。
* 支持传入多个收货单ID进行批量对照预览。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number[]} [data.receiving_ids] 收货单ID列表(优先使用)
* @param {number} [data.receiving_id] 单个收货单ID(向后兼容)
* @return {Promise<Object>} 统一 success 包装
*/
async receivingCompare(data = {}) {
const { service } = this;
const { entry_order_id, receiving_id, receiving_ids } = data || {};
const result = await service.systems.storage.entry.receivingCompare({ entry_order_id, receiving_id, receiving_ids });
return this.success('ok', result);
}
/**
* 查询入库单操作日志。warehouseId 由服务端从当前上下文自动注入,前端无需传递。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @param {number} [data.page=1] 页码
* @param {number} [data.pageSize=20] 每页数量
* @return {Promise<Object>} 统一 success 包装
*/
async queryEntryLogs(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user?.store_id;
const result = await service.systems.operationLog.queryEntryOrderLogs({
id: data.id,
warehouseId,
page: data.page,
pageSize: data.pageSize,
});
return this.success('ok', result);
}
/**
* 查询入库单已绑定收货单中匹配指定商品的可绑定收货明细列表。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} data.stock_id 商品stock_id
* @return {Promise<Object>} 统一 success 包装
*/
async getReceivingDetailsForBind(data = {}) {
const { service } = this;
const result = await service.systems.storage.entry.getReceivingDetailsForBind(data);
if (result && result.code === 200) {
return this.success('ok', result.data);
}
return this.fail(result?.message || '查询失败', result);
}
/**
* 拉取入库单绑定的收货单中,指定商品的可用容器列表(收货明细)。
* 用于 PDA 上架时选择容器。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} data.stock_id 商品stock_id
* @return {Promise<Object>} 统一 success 包装,data 包含 { list, total }
*/
async containerList(data = {}) {
const { service } = this;
const { entry_order_id, stock_id } = data || {};
const result = await service.systems.storage.entry.containerList({ entry_order_id, stock_id });
if (result && result.code === 200) {
return this.success('ok', result.data);
}
return this.fail(result?.message || '查询失败', result);
}
/**
* 审核入库单(CREATED → PENDING)。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @return {Promise<Object>} 统一 success/fail 包装
*/
async reviewEntry(data = {}) {
const { service } = this;
const result = await service.systems.entryOrder.reviewEntry(data);
if (result && result.success) {
return this.success(result.message, result.data, 200);
}
return this.fail(result?.message || '审核失败', result, 400);
}
}
module.exports = entryService;