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

470 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');
class orderServer extends MainService {
constructor(ctx) {
super(ctx);
// 初始化公共变量
this.orderType = {
JYCK: {
method: 'ORDER',
name: '一般交易出库单',
},
HHCK: {
method: 'ORDER',
name: '换货出库',
},
BFCK: {
method: 'ORDER',
name: '补发出库',
},
PTCK: {
method: 'CK',
name: '普通出库单',
},
DBCK: {
method: 'CK',
name: '调拨出库',
},
B2BCK: {
method: 'CK',
name: 'B2B出库',
},
QTCK: {
method: 'CK',
name: '其他出库',
},
CGTH: {
method: 'CK',
name: '采购退货出库单',
},
B2BRK: {
method: 'RK',
name: 'B2B入库',
},
SCRK: {
method: 'RK',
name: '生产入库',
},
LYRK: {
method: 'RK',
name: '领用入库',
},
CCRK: {
method: 'RK',
name: '残次品入库',
},
CGRK: {
method: 'RK',
name: '采购入库',
},
DBRK: {
method: 'RK',
name: '调拨入库',
},
QTRK: {
method: 'RK',
name: '其他入库',
},
XTRK: {
method: 'BACKORDER',
name: '销退入库',
},
THRK: {
method: 'BACKORDER',
name: '退货入库',
},
HHRK: {
method: 'BACKORDER',
name: '换货入库',
},
CNJG: {
method: 'JG',
name: '仓内加工单',
},
};
}
async getInterceptExpressInfo(orderId) {
const { ctx } = this;
const normalizedOrderId = Number(orderId || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
return [];
}
const orderExpressModel = ctx.model && ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findAll !== 'function') {
return [];
}
const rows = await orderExpressModel.findAll({
where: {
order_id: normalizedOrderId,
},
attributes: [ 'waybill_code', 'logistics_code', 'logistics_name', 'logistics_interface_id' ],
order: [[ 'id', 'DESC' ]],
raw: true,
});
return (Array.isArray(rows) ? rows : []).map(row => ({
waybill_code: String(row && row.waybill_code || '').trim(),
logistics_code: String(row && row.logistics_code || '').trim(),
logistics_name: String(row && row.logistics_name || '').trim(),
logistics_interface_id: row && row.logistics_interface_id == null ? null : Number(row.logistics_interface_id),
}));
}
async sendCancelInterceptNotice({ orderCode, existingOrder, info }) {
const { ctx } = this;
try {
const express = await this.getInterceptExpressInfo(existingOrder && existingOrder.id);
await ctx.service.systems.notice.send({
event: 'order_cancel_intercepted',
businessName: 'order',
warehouseId: info.warehouseId,
storeId: info.storeId,
subject: {
id: info.storeId,
type: 'store',
},
businessId: orderCode,
messageType: 'text',
title: `订单取消触发拦截:${orderCode}`,
content: `订单 ${orderCode} 因拣货/打印状态未完成,已标记为拦截执行。`,
sender: {
id: ctx.user?.employees_id || ctx.user?.id,
name: ctx.user?.employees_name || '',
},
metadata: {
orderCode,
orderId: existingOrder.id,
pickStatus: String(existingOrder.pick_status || 'none').trim(),
printStatus: String(existingOrder.print_status || 'none').trim(),
interceptStatus: String(existingOrder.intercept_status || 'none').trim(),
express,
},
});
} catch (error) {
ctx.logger.warn(`取消订单拦截通知发送失败: ${error.message}`);
}
}
async cancel(data) {
const { ctx } = this;
const info = this.getInfo();
const orderType = this.orderType[data.request.orderType];
switch (orderType.method) {
case 'ORDER':
{
const orderCode = String(data?.request?.orderCode || '').trim();
if (!orderCode) {
return this.fail('订单号不能为空');
}
const DeliveryModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(info.warehouseId);
const transaction = await ctx.model.transaction();
try {
const existingOrder = await DeliveryModel.findOne({
where: {
delivery_order_code: orderCode,
warehouse_id: info.warehouseId,
store_id: info.storeId,
},
transaction,
lock: transaction.LOCK.UPDATE,
});
if (!existingOrder) {
await transaction.rollback();
return this.fail('未找到对应的订单');
}
const pickStatus = String(existingOrder.pick_status || 'none').trim();
const printStatus = String(existingOrder.print_status || 'none').trim();
if (pickStatus !== 'none' || printStatus !== 'none') {
await existingOrder.update({
intercept_status: 'intercepting',
updated_at: new Date(),
}, {
transaction,
});
await transaction.commit();
await this.sendCancelInterceptNotice({
orderCode,
existingOrder,
info,
});
return this.fail('取消失败,已通知拦截执行');
}
// 已同步订单不允许取消,转为拦截处理
const syncStatus = String(existingOrder.sync_status || '').trim();
if (syncStatus === 'fin') {
await existingOrder.update({
intercept_status: 'requested',
updated_at: new Date(),
}, {
transaction,
});
await transaction.commit();
await this.sendCancelInterceptNotice({
orderCode,
existingOrder,
info,
});
return this.fail('订单已同步,不可取消,已转为拦截处理');
}
await existingOrder.update({
status: 'cancel',
outbound_status: 'fin',
step: 4,
updated_at: new Date(),
}, {
transaction,
});
// 释放储位分配锁定库存(wms_storage / wms_stock_warehouse)
await this.releaseStorageLockForCancel({
orderId: existingOrder.id,
warehouseId: info.warehouseId,
transaction,
});
await transaction.commit();
// 写入取消操作日志(不影响主流程)
try {
if (ctx.model && ctx.model.OperationLog) {
const customerId = String(info.customerId || '').trim();
await ctx.model.OperationLog.create({
business_type: 'order',
business_id: String(existingOrder.id),
operation_code: 'ORDER_CANCEL',
operator_id: null,
operator_name: customerId ? `qimen:${customerId}` : 'qimen',
external_log_type: 'NONE',
warehouse_id: info.warehouseId || null,
platform_code: customerId || 'SYSTEM',
message: '奇门取消订单',
});
}
} catch (logErr) {
ctx.logger.warn('[QimenOrderCancel] 写入取消操作日志失败,不影响主流程', logErr);
}
return this.success('取消订单成功');
} catch (error) {
try {
await transaction.rollback();
} catch (rollbackError) {
ctx.logger.error('取消订单回滚失败', rollbackError);
}
ctx.logger.error(`取消订单失败: ${error.message}`);
return this.fail(error.message || '取消订单失败');
}
}
case 'RK':
{
const existingOrder = await ctx.model.EntryOrder.findOne({
where: {
entry_order_code: data.request.orderCode,
warehouse_id: info.warehouseId,
store_id: info.storeId,
},
});
if (existingOrder) {
await existingOrder.update({
order_status: 'CANCELLED',
updated_at: new Date(),
});
return this.success('取消入库单成功');
}
return this.fail('未找到对应的入库单');
}
case 'CK':
return this.fail('取消出库单未开发完成');
case 'JG':
return this.fail('取消加工单未开发完成');
case 'BACKORDER':
return this.fail('取消退货单未开发完成');
default:
return this.fail(`未识别的作业类型${orderType.method}`, {});
}
}
/**
* 取消订单时释放储位分配锁定库存。
* - 有 wms_picking 记录时:释放 wms_storage.locked_quantity 与 wms_stock_warehouse.locked_quantity,
* 并删除对应的 wms_picking 分配记录。
* - 无 wms_picking 记录时:从 wms_order_items 查询该订单的 stock_id 与 plan_qty,
* 只释放 wms_stock_warehouse.locked_quantity。
*
* @param {Object} options - 释放参数。
* @param {number} options.orderId - 订单ID。
* @param {number} options.warehouseId - 仓库ID。
* @param {Object} options.transaction - 数据库事务对象。
* @return {Promise<void>}
*/
async releaseStorageLockForCancel({ orderId, warehouseId, transaction } = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
if (!orderId || !warehouseId) {
return;
}
const pickingModel = ctx.model.Picking;
const storageModel = ctx.model.Storage;
const stockModel = ctx.model.StockWarehouse;
if (!pickingModel || !storageModel || !stockModel) {
ctx.logger.warn('[qimen order.cancel releaseStorageLockForCancel] 模型不可用,跳过库存释放');
return;
}
// 查找该订单的有效分配记录
const pickingRows = await pickingModel.findAll({
where: {
order_id: orderId,
status: { [Op.ne]: 'cancel' },
},
transaction,
lock: transaction.LOCK.UPDATE,
raw: true,
});
if (!Array.isArray(pickingRows) || pickingRows.length === 0) {
// 无储位分配记录:从订单明细获取锁定信息,只释放 stock_warehouse 锁
const orderItemsModel = await ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
if (!orderItemsModel) {
ctx.logger.warn('[qimen order.cancel releaseStorageLockForCancel] OrderItems 模型不可用,跳过库存释放');
return;
}
const orderItems = await orderItemsModel.findAll({
where: { order_id: orderId },
attributes: [ 'stock_id', 'plan_qty' ],
raw: true,
transaction,
});
for (const item of orderItems) {
const stockId = Number(item.stock_id || 0);
const qty = Number(item.plan_qty || 0);
if (stockId <= 0 || qty <= 0) continue;
await ctx.service.systems.stockStore.updateLockedQuantity(stockId, -qty, transaction, {
remark: '奇门取消订单-释放创建锁',
orderType: 'ORDER_CANCEL',
orderNo: String(orderId),
orderId,
});
}
return;
}
// 按 storage_id 汇总释放数量
const storageQuantityMap = new Map();
for (const row of pickingRows) {
const storageId = Number(row.storage_id || 0);
const quantity = Number(row.quantity || 0);
if (storageId > 0 && quantity > 0) {
storageQuantityMap.set(storageId, (storageQuantityMap.get(storageId) || 0) + quantity);
}
}
if (storageQuantityMap.size === 0) {
return;
}
// 查出关联的 wms_storage 记录,获取 stock_id
const storageIds = Array.from(storageQuantityMap.keys());
const storageRows = await storageModel.findAll({
where: {
id: { [Op.in]: storageIds },
},
transaction,
lock: transaction.LOCK.UPDATE,
raw: true,
});
const storageMap = new Map();
for (const row of storageRows) {
storageMap.set(Number(row.id), row);
}
// 依次释放 wms_storage 与 wms_stock_warehouse 锁定数量
for (const [ storageId, quantity ] of storageQuantityMap.entries()) {
const storageRow = storageMap.get(storageId);
if (!storageRow) {
ctx.logger.warn(`[qimen order.cancel] 库存记录不存在,跳过: storageId=${storageId}`);
continue;
}
const stockId = Number(storageRow.stock_id || 0);
if (stockId <= 0) {
ctx.logger.warn(`[qimen order.cancel] 库存记录缺少 stock_id,跳过: storageId=${storageId}`);
continue;
}
// 释放 wms_storage.locked_quantity
await ctx.service.systems.storage.index.unlockQuantity(storageId, quantity, { transaction });
// 释放 wms_stock_warehouse.locked_quantity
const releaseResult = await ctx.service.systems.stockStore.updateLockedQuantity(
stockId, -Number(quantity), transaction, {
remark: '奇门取消订单-释放储位锁',
orderType: 'ORDER_CANCEL',
orderNo: String(orderId),
orderId,
}
);
if (!releaseResult.success) {
throw new Error(`库存主记录释放失败: stockId=${stockId}, ${releaseResult.error}`);
}
}
// 删除已释放的分配记录
const pickingIds = pickingRows
.map(row => Number(row.id || 0))
.filter(id => id > 0);
if (pickingIds.length > 0) {
await pickingModel.destroy({
where: {
id: { [Op.in]: pickingIds },
},
transaction,
});
}
}
async pending(data) {
const orderType = this.orderType[data.request.orderType];
switch (orderType.method) {
case 'ORDER':
return this.fail('锁定订单未开发完成');
case 'RK':
return this.fail('锁定入库单未开发完成');
case 'CK':
return this.fail('锁定出库单未开发完成');
case 'JG':
return this.fail('锁定加工单未开发完成');
case 'BACKORDER':
return this.fail('锁定退货单未开发完成');
default:
return this.fail(`未识别的作业类型${orderType.method}`, {});
}
}
}
module.exports = orderServer;