- 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 补变更记录
1016 lines
32 KiB
JavaScript
1016 lines
32 KiB
JavaScript
'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;
|