WMS_MAIN/app/service/systems/entry_order.js
liufumingren b5e5d4d588 feat(storeWarehouse,report,notice,order): 签约导出与代开户备注兜底、报表meta下线、入库完成通知与编码规范化
- storeWarehouse: 货主签约列表异步导出 export/exportTaskProgress(26列中文表头Excel+进度回写);openAccount 代开户未传 store_remask(或传空)时默认取公司全称前50字符填充,保证货主名称在列表/导出中始终有值

- report: 下线 report.meta(破坏性),窗口参数改由 definition.typeList、勾选字段经 definition.list 提供;报表投递目标货主状态放宽为 1/2(正常/审核中);reportDelivery 实体展示名称兼容下划线/驼峰并优雅回退 ID

- notice/order: 入库单完成通知货主(entry_order_completed,固定订阅回退链:收货组→售后组→仓库异常群);入库明细 itemId 规范化(非法值降级按 item_code 精确/归一化条码匹配,剥离中文后缀,多命中报错防错配);库存预警定时任务与 webhook 模型调整

- storage: 快捷直入/入库单基本信息等相关小改(inbound_direct_log、storage/entry、storage/inventory)

- docs: methods/system 0.3.62→0.3.63、openapi/qimen 同步,AI_METHOD_ROUTING 与 report-config-guide 同步,methods/changes/*.json 补变更记录
2026-08-31 17:17:48 +08:00

1016 lines
32 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const Service = require('egg').Service;
/**
* 校验商品 ID 是否合法:必须是纯数字且未超出 BIGINT(20) 有符号范围。
* @param {string|number|null|undefined} value 待校验的商品 ID
* @return {boolean} 合法返回 true,否则返回 false
*/
function isValidItemId(value) {
if (value === null || value === undefined || value === '') return false;
const str = String(value);
// 纯数字校验
if (!/^\d+$/.test(str)) return false;
try {
// BIGINT(20) 有符号上限 9223372036854775807,超出范围视为非法
return BigInt(str) <= BigInt('9223372036854775807');
} catch (error) {
return false;
}
}
/**
* 提取商品编码开头的连续数字,作为归一化条码用于商品匹配。
* 用于剥离中文后缀(如 "6934864201409-新品" → "6934864201409"):
* - 纯数字编码原样返回(与精确匹配等价);
* - 编码不以数字开头时无法归一化,返回 null;
* - 只取开头连续数字段,后续任意字符(中英文、符号、空格)一律视为后缀丢弃。
* @param {string|number|null|undefined} value 原始商品编码(itemCode)
* @return {string|null} 归一化后的纯数字条码;无法归一化返回 null
*/
function normalizeItemCodeForMatch(value) {
if (value === null || value === undefined) return null;
const str = String(value).trim();
if (!str) return null;
const matched = str.match(/^\d+/);
return matched ? matched[0] : null;
}
class entryOrderService extends Service {
/**
* 创建入库单(含明细行校验与插入)。
* 明细行商品匹配优先级:itemId 主键 > itemCode 精确匹配 > itemCode 归一化条码匹配;
* 带中文后缀的编码(如 6934864201409-新品)在精确匹配不到时剥离后缀按纯数字条码对齐,
* 归一化条码对应多个商品时按失败处理,避免错配。
* @param {Object} data 请求体,包含 request.entryOrder 与 request.orderLines
* @param {Object} info 上下文信息 { storeId, warehouseId, appKey, customerId, warehouseCode }
* @param {string} fromCode 来源标识(WMS / API / QM)
* @param {Object} [options={}] 可选配置
* @param {boolean} [options.autoReview=false] 是否自动审核,true 时入库单创建后状态直接变为 PENDING
* @return {Promise<Object>} { success, message, data: { entryOrderId, entryOrderCode, createTime, warehouseCode, status } }
*/
async addOrder(data, info, fromCode, options = {}) {
const { autoReview = false } = options;
const { storeId, warehouseId, appKey, customerId, warehouseCode } = info;
const { app, ctx } = this;
const transaction = await app.model.transaction(); // 开启事务
try {
let totalOrderLines = data.request.entryOrder.totalOrderLines || 0;
let orderLine = data.request.orderLines.orderLine;
if (orderLine.itemCode) {
orderLine = [ orderLine ];
}
totalOrderLines = totalOrderLines || orderLine.length;
let errors = [];
const items = [];
// 验证商品
for (let i = 0; i < orderLine.length; i++) {
const line = orderLine[i];
const lineNo = line.orderLineNo || i + 1;
// 请求行展示信息:取自原始报文,保证失败提示展示真实 SKU/商品/编码
const lineItemId = line.itemId ?? '';
const lineItemName = line.itemName || '';
const lineItemCode = line.itemCode || '';
let wms_stock = null;
// ERP不处理WMS的外部商品编码
// 查找唯一键:按商品编码精确查找(限定 appKey/仓库/货主作用域,作用域内 item_code 唯一)
const findByItemCode = async itemCode => {
if (!itemCode) return null;
return await app.model.StockStore.findOne({ where: {
item_code: itemCode,
app_key: appKey,
warehouse_id: warehouseId,
store_id: storeId,
}, transaction });
};
// itemId 必须是纯数字且在 BIGINT 范围内才可作为商品主键使用,
// 非法值(如带中文后缀的编码)视为未提供,降级按 item_code 匹配
const validItemId = isValidItemId(line.itemId) ? String(line.itemId) : null;
if (validItemId) {
wms_stock = await app.model.StockStore.findByPk(validItemId, { transaction });
// 校验 StockStore 记录的 store_id 与当前上下文一致,防止跨货主越权
if (wms_stock && Number(wms_stock.store_id) !== Number(storeId)) {
wms_stock = null;
}
}
// 匹配优先级:itemId 主键 > itemCode 精确匹配 > itemCode 归一化条码匹配
// 外部渠道 itemId 可能是平台商品标识或条码而非 WMS 主键,主键查不到时降级按 item_code 查找
if (!wms_stock) {
wms_stock = await findByItemCode(lineItemCode);
}
// 带中文后缀的编码(如 6934864201409-新品)精确匹配不到时,
// 剥离后缀按纯数字条码与 StockStore.item_code 对齐匹配
if (!wms_stock) {
const normalizedBarcode = normalizeItemCodeForMatch(lineItemCode);
if (normalizedBarcode && normalizedBarcode !== lineItemCode) {
const normalizedRows = await app.model.StockStore.findAll({
where: {
item_code: normalizedBarcode,
app_key: appKey,
warehouse_id: warehouseId,
store_id: storeId,
},
transaction,
});
if (normalizedRows.length === 1) {
wms_stock = normalizedRows[0];
} else if (normalizedRows.length > 1) {
// 同一归一化条码对应多个商品,无法确定唯一 SKU,按失败处理,避免错配
errors.push(`订单行${lineNo}:编码《${lineItemCode}》归一化条码《${normalizedBarcode}》匹配到多个商品,请人工核对后重试`);
continue;
}
}
}
if (!wms_stock) {
errors.push(`订单行${lineNo}:SKU${lineItemId}商品《${lineItemName}》编码《${lineItemCode}》\n未同步推送到仓库`);
continue;
}
if (!wms_stock.stock_id) {
errors.push(`订单行${lineNo}:SKU${lineItemId}商品《${lineItemName}》编码《${lineItemCode}》wms无对应关系\n请联系仓库关联创建商品`);
continue;
}
wms_stock.inventory_type = line.inventoryType || 'ZP';
wms_stock.order_line_no = line.orderLineNo || i + 1;
wms_stock.count = line.planQty;
// item_id 统一写入实际匹配到的 StockStore 主键 id(纯数字),
// 避免中文后缀等非数字值写入 BIGINT 列触发 MySQL 严格模式报错
wms_stock.item_id = wms_stock.id;
items.push(wms_stock);
}
if (errors.length > 0) {
await transaction.rollback(); // 验证失败,回滚事务
return {
success: false,
message: `创建入库单失败,失败原因:\n${errors.join('\n')}`,
data: {
createTime: new Date(),
},
};
}
// 创建入库单(内部也使用事务),autoReview 在 addOrder 层控制最终状态
const order = await this.tryCreateEntryOrder(
data.request.entryOrder,
appKey,
storeId,
warehouseId,
totalOrderLines,
fromCode,
customerId,
warehouseCode,
transaction // 传递事务
);
if (!order.success) {
await transaction.rollback();
return {
success: false,
message: '创建入库单失败,失败原因:\n' + order.error,
data: {
createTime: new Date(),
},
};
}
const orderId = order.entryOrderId;
const orderCode = order.entryOrderCode || data.request.entryOrder.entryOrderCode;
errors = []; // 重置错误数组
// 添加商品明细
for (let i = 0; i < items.length; i++) {
const item = items[i];
const res = await this.addItems(item, orderId, transaction);
if (!res.success) {
// item.item_id / item.item_name / item.item_code 均取自校验阶段实际匹配到的 StockStore 实例,
// 保证失败行展示真实的 SKU 主键、商品名称与商品编码
errors.push(`订单行${item.order_line_no}:SKU${item.item_id}商品《${item.item_name}》编码《${item.item_code}》入库失败,错误信息:${res.error}`);
}
}
if (errors.length > 0) {
await transaction.rollback(); // 商品添加失败,回滚整个事务
return {
success: false,
message: '创建入库单失败,失败原因:\n' + errors.join('\n'),
data: {
createTime: new Date(),
},
};
}
// 获取接收行数并处理状态
const lineCount = await this.getLineCount(orderId, transaction);
const expectedTotalOrderLines = Number(totalOrderLines) || 0;
// autoReview 决定最终状态:true → PENDING(已审核),false → CREATED(已创建待审核)
const finalStatus = autoReview ? 'PENDING' : 'CREATED';
if (lineCount === expectedTotalOrderLines) {
// 所有明细行已插入完毕,将状态从 CREATING 更新为目标状态
await app.model.EntryOrder.update(
{ order_status: finalStatus, updated_at: new Date() },
{ where: { id: orderId, warehouse_id: warehouseId, store_id: storeId }, transaction }
);
}
// 写入操作日志
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry_order',
businessId: orderId,
operationCode: 'ENTRY_ORDER_CREATE',
operator: {
id: ctx.user?.employees_id || ctx.user?.id || '',
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId,
storeId,
entryOrderCode: orderCode,
sourceType: fromCode,
totalOrderLines,
finalStatus,
},
transaction,
});
// 提交事务
await transaction.commit();
// 异步匹配收货单并写入绑定关系(不阻塞 addOrder 返回)
if (lineCount === expectedTotalOrderLines) {
setImmediate(() => {
ctx.service.systems.receivingEntryMatch.matchAfterEntryCompleted(orderId).catch(err => {
ctx.logger.error(`[addOrder] 异步匹配收货单异常: ${err.message}`, err.stack);
});
});
}
if (lineCount === expectedTotalOrderLines) {
return {
success: true,
message: '入库单创建完成',
data: {
entryOrderId: orderId,
entryOrderCode: orderCode,
createTime: new Date(),
warehouseCode,
status: finalStatus,
},
};
}
// 部分接收或等待接收
return {
success: true,
message: '入库单创建中',
data: {
entryOrderId: orderId,
entryOrderCode: orderCode,
createTime: new Date(),
warehouseCode,
status: 'CREATING',
},
};
} catch (error) {
// 发生异常,回滚事务
await transaction.rollback().catch(e => ctx.logger.error(`回滚事务失败: ${e.message}`, e));
ctx.logger.error(`addOrder 事务异常: ${error.message}`, error);
return {
success: false,
message: `系统异常: ${error.message}`,
data: {
createTime: new Date(),
},
};
}
}
/**
* 获取入库单的明细行数(支持事务)。
* @param {number} orderId 入库单ID
* @param {Object|null} [transaction=null] 可选事务对象
* @return {Promise<number>} 明细行数
*/
async getLineCount(orderId, transaction = null) {
const { app } = this;
const options = {
where: { order_id: orderId },
};
if (transaction) {
options.transaction = transaction;
}
const count = await app.model.EntryItems.count(options);
return count;
}
/**
* 标记入库单为已完成(支持事务)。
* @param {number} orderId 入库单ID
* @param {number} warehouseId 仓库ID
* @param {number} storeId 货主ID
* @param {Object|null} [transaction=null] 可选事务对象
* @return {Promise<void>}
*/
async received(orderId, warehouseId, storeId, transaction = null) {
const { app } = this;
const updateData = {
order_status: 'COMPLETED',
updated_at: new Date(),
};
const where = {
id: orderId,
warehouse_id: warehouseId,
store_id: storeId,
};
if (transaction) {
await app.model.EntryOrder.update(updateData, {
where,
transaction,
});
} else {
await app.model.EntryOrder.update(updateData, { where });
}
}
// 辅助函数:统一返回格式
success(message, data = {}) {
return {
success: true,
message,
data: {
...data,
createTime: new Date(),
},
};
}
fail(message, data = {}) {
return {
success: false,
message,
data: {
...data,
createTime: new Date(),
},
};
}
async findByOrderCode(entryOrderCode, warehouseId, storeId) {
const { ctx } = this;
return await ctx.model.EntryOrder.findOne({
where: {
entry_order_code: entryOrderCode,
warehouse_id: warehouseId,
store_id: storeId,
is_enabled: 1,
deleted_at: null,
},
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [[ 'company_name', 'store_name' ]],
},
{
model: ctx.model.Store,
as: 'store',
attributes: [[ 'company_name', 'store_name' ]],
},
{
model: ctx.model.EntryItems,
as: 'items',
include: [
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [ 'item_code', 'item_name' ],
},
],
},
],
});
}
async findByStatus(status, params = {}) {
const { ctx, app } = this;
const { warehouse_id, store_id, start_date, end_date, page = 1, pageSize = 20 } = params;
const where = {
order_status: status,
is_enabled: 1,
deleted_at: null,
};
if (warehouse_id) {
where.warehouse_id = warehouse_id;
}
if (store_id) {
where.store_id = store_id;
}
if (start_date || end_date) {
where.created_at = {};
if (start_date) {
where.created_at[app.Sequelize.Op.gte] = start_date;
}
if (end_date) {
where.created_at[app.Sequelize.Op.lte] = end_date;
}
}
const currentPage = Math.max(Number(page) || 1, 1);
const currentPageSize = Math.max(Number(pageSize) || 20, 1);
const { count, rows } = await ctx.model.EntryOrder.findAndCountAll({
where,
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [[ 'company_name', 'store_name' ]],
},
{
model: ctx.model.Store,
as: 'store',
attributes: [[ 'company_name', 'store_name' ]],
},
],
order: [[ 'created_at', 'DESC' ]],
offset: (currentPage - 1) * currentPageSize,
limit: currentPageSize,
distinct: true,
});
return {
list: rows,
pagination: {
page: currentPage,
pageSize: currentPageSize,
total: count,
totalPages: Math.ceil(count / currentPageSize),
},
};
}
async getStatsByWarehouse(warehouseId, startDate, endDate) {
const { ctx, app } = this;
const where = {
warehouse_id: warehouseId,
is_enabled: 1,
deleted_at: null,
};
if (startDate || endDate) {
where.created_at = {};
if (startDate) {
where.created_at[app.Sequelize.Op.gte] = startDate;
}
if (endDate) {
where.created_at[app.Sequelize.Op.lte] = endDate;
}
}
const result = await ctx.model.EntryOrder.findAll({
attributes: [
'order_status',
[ app.Sequelize.fn('COUNT', app.Sequelize.col('id')), 'count' ],
[ app.Sequelize.fn('SUM', app.Sequelize.col('total_order_lines')), 'total_lines' ],
],
where,
group: [ 'order_status' ],
raw: true,
});
const stats = {
pending: 0,
completed: 0,
cancelled: 0,
total: 0,
total_lines: 0,
};
result.forEach(item => {
const status = String(item.order_status || '').toLowerCase();
const count = parseInt(item.count, 10) || 0;
const totalLines = parseInt(item.total_lines, 10) || 0;
if (stats[status] !== undefined) {
stats[status] = count;
}
stats.total += count;
stats.total_lines += totalLines;
});
return stats;
}
async updateSyncStatus(orderId, status, message = null, options = {}) {
const { ctx } = this;
const order = await ctx.model.EntryOrder.findByPk(orderId, {
transaction: options.transaction,
});
if (!order) {
throw new Error('入库单不存在');
}
const updateData = {
sync_status: status,
};
if (message !== null) {
updateData.sync_message = message;
}
return await order.update(updateData, {
transaction: options.transaction,
});
}
async updateOrderStatus(orderId, status, options = {}) {
const { ctx } = this;
const order = await ctx.model.EntryOrder.findByPk(orderId, {
transaction: options.transaction,
});
if (!order) {
throw new Error('入库单不存在');
}
const validTransitions = {
CREATED: [ 'PENDING', 'CANCELLED' ],
PENDING: [ 'COMPLETED', 'CANCELLED' ],
CREATING: [ 'CREATED', 'CANCELLED' ],
};
const allowedTransitions = validTransitions[order.order_status];
if (!allowedTransitions || !allowedTransitions.includes(status)) {
throw new Error(`状态从${order.order_status}转换到${status}不被允许`);
}
return await order.update({ order_status: status }, {
transaction: options.transaction,
});
}
async calculateReceivedQuantities(orderId) {
const { ctx, app } = this;
const order = await ctx.model.EntryOrder.findByPk(orderId, {
attributes: [ 'id', 'entry_order_code' ],
raw: true,
});
if (!order) {
throw new Error('入库单不存在');
}
const items = await ctx.model.EntryItems.findAll({
where: { order_id: orderId },
attributes: [ 'id', 'count', 'item_id' ],
raw: true,
});
const itemIds = [ ...new Set(items.map(item => item.item_id).filter(Boolean)) ];
const receivedRows = itemIds.length > 0
? await ctx.model.Storage.findAll({
where: {
inbound_order_no: order.entry_order_code,
item_id: itemIds,
},
attributes: [
'item_id',
[ app.Sequelize.fn('SUM', app.Sequelize.col('quantity')), 'received' ],
],
group: [ 'item_id' ],
raw: true,
})
: [];
const receivedMap = new Map(
receivedRows.map(row => [ Number(row.item_id), Number(row.received) || 0 ])
);
let totalExpected = 0;
let totalReceived = 0;
let allReceived = items.length > 0;
let anyReceived = false;
items.forEach(item => {
const expected = Number(item.count) || 0;
const received = receivedMap.get(Number(item.item_id)) || 0;
totalExpected += expected;
totalReceived += received;
if (expected > 0 && received < expected) {
allReceived = false;
}
if (received > 0) {
anyReceived = true;
}
});
return {
total_expected: totalExpected,
total_received: totalReceived,
all_received: allReceived,
any_received: anyReceived,
percentage: totalExpected > 0 ? Math.round((totalReceived / totalExpected) * 100) : 0,
};
}
async batchUpdateReceived(updates, options = {}) {
const { ctx } = this;
const externalTransaction = options.transaction || null;
const transaction = externalTransaction || await ctx.model.transaction();
try {
const pendingUpdates = [];
for (const update of updates) {
const { id, quantity } = update;
const item = await ctx.model.EntryItems.findByPk(id, { transaction });
if (!item) {
throw new Error(`入库明细 ${id} 不存在`);
}
item.validateReceiveQuantity(quantity);
pendingUpdates.push({
item,
quantity,
});
}
for (const pending of pendingUpdates) {
const newReceived = (pending.item.received_quantity || 0) + pending.quantity;
await pending.item.update({
received_quantity: newReceived,
}, { transaction });
}
if (!externalTransaction) {
await transaction.commit();
}
return { success: true };
} catch (error) {
if (!externalTransaction) {
await transaction.rollback();
}
throw error;
}
}
async getOrderProgress(orderId) {
const { ctx, app } = this;
const items = await ctx.model.EntryItems.findAll({
where: { order_id: orderId },
attributes: [
[ app.Sequelize.fn('SUM', app.Sequelize.col('count')), 'total_plan' ],
[ app.Sequelize.fn('SUM', app.Sequelize.col('received_quantity')), 'total_received' ],
[ app.Sequelize.fn('COUNT', app.Sequelize.col('id')), 'item_count' ],
],
raw: true,
});
const result = items[0] || {};
const totalPlan = parseInt(result.total_plan, 10) || 0;
const totalReceived = parseInt(result.total_received, 10) || 0;
return {
total_plan: totalPlan,
total_received: totalReceived,
total_remaining: Math.max(0, totalPlan - totalReceived),
item_count: parseInt(result.item_count, 10) || 0,
progress_percent: totalPlan > 0 ? Math.min(100, Math.round((totalReceived / totalPlan) * 100)) : 0,
is_completed: totalReceived >= totalPlan,
};
}
/**
* 尝试创建入库单(含去重与状态校验)。
* 若入库单已存在且状态为 CREATING,则复用该记录;否则新建,初始状态为 CREATING。
* 最终状态(CREATED / PENDING)由调用方 addOrder 根据 autoReview 决定。
* @param {Object} order 入库单基本信息
* @param {string} appKey 应用标识
* @param {number} storeId 货主ID
* @param {number} warehouseId 仓库ID
* @param {number} totalOrderLines 总行数
* @param {string} sourceType 来源类型(WMS / API / QM)
* @param {string|null} qimenOwnerCode 奇门货主编码
* @param {string|null} qimenWarehouseCode 奇门仓库编码
* @param {Object|null} [transaction=null] 外部事务对象
* @return {Promise<Object>} { success, code, message, entryOrderId, entryOrderCode, orderStatus, error? }
*/
async tryCreateEntryOrder(order, appKey, storeId, warehouseId, totalOrderLines, sourceType, qimenOwnerCode, qimenWarehouseCode, transaction = null) {
const { ctx } = this;
try {
const options = transaction ? { transaction } : {};
// 1. 检查入库单是否已存在
const existingOrder = await ctx.model.EntryOrder.findOne({
where: {
entry_order_code: order.entryOrderCode,
warehouse_id: warehouseId,
store_id: storeId,
},
...options,
});
// 2. 如果入库单已存在
if (existingOrder) {
const allowedStatuses = [ 'CREATING' ];
if (allowedStatuses.includes(existingOrder.order_status)) {
// 状态在允许范围内,更新为接收中状态
await existingOrder.update({
order_status: 'CREATING',
updated_at: new Date(),
}, options);
return {
success: true,
code: 1,
message: '入库单已存在,状态已更新为接收中',
entryOrderId: existingOrder.id,
entryOrderCode: existingOrder.entry_order_code,
orderStatus: 'CREATING',
items: existingOrder.items || [],
data: {
entryOrder: {
id: existingOrder.id,
entryOrderCode: existingOrder.entry_order_code,
orderType: existingOrder.order_type,
orderStatus: existingOrder.order_status,
totalOrderLines,
},
},
};
}
// 其他状态返回错误
const statusName = existingOrder.getOrderStatusName ? existingOrder.getOrderStatusName() : existingOrder.order_status;
return {
success: false,
code: 0,
message: `入库单已存在,当前状态为${statusName},无法重复创建`,
entryOrderId: existingOrder.id,
entryOrderCode: existingOrder.entry_order_code,
orderStatus: existingOrder.order_status,
error: `入库单已存在,状态: ${statusName}`,
};
}
// 3. 入库单不存在,创建新的入库单
// 如果外部传入了事务,使用外部事务;否则创建新事务
const internalTransaction = transaction ? null : await ctx.model.transaction();
const currentTransaction = transaction || internalTransaction;
try {
const warehouse_data = await this.ctx.service.systems.store.getStoreName(warehouseId);
let store_name = null;
let warehouse_name = null;
if (warehouse_data.code === 200) {
warehouse_name = warehouse_data.data.company_name;
}
const store_data = await this.ctx.service.systems.store.getStoreName(storeId);
if (store_data.code === 200) {
store_name = store_data.data.company_name;
}
const contract_data = await this.ctx.service.systems.store.getStoreRemaskName(storeId, warehouseId);
let contract = null;
if (contract_data.code === 200) {
contract = contract_data.data;
}
// 构建入库单数据
const entryOrderData = {
entry_order_code: order.entryOrderCode,
order_type: order.orderType,
purchase_order_code: order.relatedOrders?.relatedOrder?.orderCode || '',
total_order_lines: totalOrderLines,
order_create_time: order.orderCreateTime ? new Date(order.orderCreateTime) : new Date(),
expect_start_time: order.expectStartTime ? new Date(order.expectStartTime) : new Date(),
expect_end_time: order.expectEndTime ? new Date(order.expectEndTime) : new Date(),
logistics_code: order.logisticsCode || '',
logistics_name: order.logisticsName || '',
express_code: order.expressCode || '',
supplier_code: order.supplierCode || '',
supplier_name: order.supplierName || '',
source_type: sourceType,
order_status: 'CREATING',
sync_status: 'PENDING',
sync_message: '',
is_enabled: 1,
warehouse_id: warehouseId,
store_id: storeId,
store_name: contract.store_remask || store_name,
warehouse_name: contract.warehouse_remask || warehouse_name,
remark: order.remark || '',
qimen_owner_code: qimenOwnerCode || '',
qimen_warehouse_code: qimenWarehouseCode || '',
};
// 创建入库单
const newEntryOrder = await ctx.model.EntryOrder.create(entryOrderData, {
transaction: currentTransaction,
});
// 如果这是内部创建的事务,提交它
if (internalTransaction) {
await internalTransaction.commit();
}
return {
success: true,
code: 1,
message: '入库单创建成功,状态设置为接收中',
entryOrderId: newEntryOrder.id,
entryOrderCode: newEntryOrder.entry_order_code,
};
} catch (error) {
// 如果这是内部创建的事务,回滚它
if (internalTransaction) {
await internalTransaction.rollback();
}
throw error;
}
} catch (error) {
console.error('创建入库单失败:', error);
return {
success: false,
code: 0,
message: `创建入库单异常: ${error.message}`,
entryOrderId: null,
entryOrderCode: null,
orderStatus: null,
error: error.message,
};
}
}
/**
* 添加入库单明细行(按 order_line_no 幂等去重)。
* 写入前将 item_id 强制转为合法数字,非法值兜底为 0,
* 避免中文后缀等非数字值写入 BIGINT 列触发 MySQL 严格模式报错。
* @param {Object} item 明细行数据(来自 StockStore 实例并附加了 order_line_no / count / item_id 等字段)
* @param {number} orderId 入库单 ID
* @param {Object|null} [transaction=null] 可选事务对象
* @return {Promise<Object>} { success, code, message? } 成功时 code=1
*/
async addItems(item, orderId, transaction = null) {
const { ctx } = this;
try {
const options = transaction ? { transaction } : {};
// 检查商品是否已存在
const existingOrderItem = await ctx.model.EntryItems.findOne({
where: {
order_id: orderId,
order_line_no: item.order_line_no,
},
...options,
});
if (!existingOrderItem) {
try {
// item_id 必须是合法数字(StockStore 主键),非法值兜底为 0
const numericItemId = Number(item.item_id);
// 构建入库明细数据
const entryItemsData = {
order_id: orderId,
out_biz_code: item.out_biz_code || '',
order_line_no: item.order_line_no || '',
owner_code: item.owner_code || '',
item_code: item.item_code || '',
item_id: Number.isFinite(numericItemId) ? numericItemId : 0,
count: item.count || 0,
inventory_type: item.inventory_type || '',
stock_id: item.stock_id || '',
};
// 创建入库明细
await ctx.model.EntryItems.create(entryItemsData, {
transaction,
});
return {
success: true,
code: 1,
};
} catch (error) {
throw error;
}
}
return {
success: true,
code: 1,
message: '商品已存在,跳过重复添加',
};
} catch (error) {
console.error('添加入库单商品失败:', error);
return {
success: false,
code: 0,
message: `添加商品失败: ${error.message}`,
error: error.message,
};
}
}
/**
* 审核入库单(CREATED → PENDING)。
* 只允许已绑定收货单的入库单推进状态,未绑定则拒绝。
*
* @param {Object} data 请求体
* @param {number} data.id 入库单 ID
* @return {Promise<Object>} { success, message, data }
*/
async reviewEntry(data = {}) {
const { app, ctx } = this;
const orderId = Number(data.id || 0);
if (!orderId) {
return { success: false, message: 'id 必填' };
}
const entryOrder = await app.model.EntryOrder.findOne({
where: { id: orderId, is_enabled: 1, deleted_at: null },
});
if (!entryOrder) {
return { success: false, message: '入库单不存在' };
}
if (entryOrder.order_status !== 'CREATED') {
return {
success: false,
message: `当前状态[${entryOrder.order_status}]不允许审核,仅 CREATED 可审核`,
};
}
// 校验:必须有绑定的收货单
const hasReceiving = await ctx.model.EntryOrderReceiving.findOne({
where: { entry_order_id: orderId, deleted_at: null },
});
if (!hasReceiving) {
return {
success: false,
message: '入库单未绑定收货单,请先绑定收货单后再审核',
};
}
// 推进状态
await entryOrder.update({
order_status: 'PENDING',
updated_at: new Date(),
});
// 写操作日志
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'entry_order',
businessId: entryOrder.id,
operationCode: 'ENTRY_ORDER_REVIEW',
operator: {
id: ctx.user?.employees_id || ctx.user?.id || '',
name: ctx.user?.employees_name || '',
},
extras: {
warehouseId: entryOrder.warehouse_id,
message: '入库单审核通过(CREATED → PENDING)',
},
});
return {
success: true,
message: '审核成功',
data: { id: entryOrder.id, order_status: 'PENDING' },
};
}
}
module.exports = entryOrderService;