'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, }); // 同步更新运单表拦截标记 try { await ctx.model.OrderExpress.update( { is_intercept: 'Y' }, { where: { order_id: existingOrder.id, warehouse_id: info.warehouseId }, transaction } ); } catch (expressErr) { ctx.logger.warn( `[qimen order cancel] 更新运单拦截标记失败, orderId=${existingOrder.id}, error=${expressErr.message}` ); } await transaction.commit(); // 写入拦截操作日志(失败不影响主流程) try { if (ctx.model && ctx.model.OperationLog) { const customerId2 = String(info.customerId || '').trim(); await ctx.model.OperationLog.create({ business_type: 'order', business_id: String(existingOrder.id), operation_code: 'ORDER_INTERCEPT_REQUEST', operator_id: null, operator_name: customerId2 ? `qimen:${customerId2}` : 'qimen', external_log_type: 'NONE', warehouse_id: info.warehouseId || null, platform_code: customerId2 || 'SYSTEM', message: '奇门取消订单-触发拦截', }); } } catch (logErr) { ctx.logger.warn('[QimenOrderCancel] 写入拦截操作日志失败,不影响主流程', logErr); } // 创建售后工单 + 通知快递群(仅限有运单的订单,与正常货主发起拦截一致;失败不影响主流程) try { const interceptExpress = await this.getInterceptExpressInfo(existingOrder.id); if (Array.isArray(interceptExpress) && interceptExpress.length > 0) { await ctx.service.systems.afterSale.createInterceptWorkOrdersAndNotify({ orderIds: [ existingOrder.id ], warehouseId: info.warehouseId, creatorLabel: ctx.user?.employees_name || '奇门系统', }); } } catch (workOrderErr) { ctx.logger.warn( `[qimen order cancel] 创建工单/通知失败, orderId=${existingOrder.id}, error=${workOrderErr.message}` ); } 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, }); // 同步更新运单表拦截标记 try { await ctx.model.OrderExpress.update( { is_intercept: 'Y' }, { where: { order_id: existingOrder.id, warehouse_id: info.warehouseId }, transaction } ); } catch (expressErr) { ctx.logger.warn( `[qimen order cancel] 更新运单拦截标记失败(sync), orderId=${existingOrder.id}, error=${expressErr.message}` ); } await transaction.commit(); // 创建售后工单 + 通知快递群(仅限有运单的订单,与正常货主发起拦截一致;失败不影响主流程) try { const interceptExpress = await this.getInterceptExpressInfo(existingOrder.id); if (Array.isArray(interceptExpress) && interceptExpress.length > 0) { await ctx.service.systems.afterSale.createInterceptWorkOrdersAndNotify({ orderIds: [ existingOrder.id ], warehouseId: info.warehouseId, creatorLabel: ctx.user?.employees_name || '奇门系统', }); } } catch (workOrderErr) { ctx.logger.warn( `[qimen order cancel] 创建工单/通知失败(sync), orderId=${existingOrder.id}, error=${workOrderErr.message}` ); } await this.sendCancelInterceptNotice({ orderCode, existingOrder, info, }); return this.fail('订单已同步,不可取消,已转为拦截处理'); } // 检查是否在波次中,若在波次中需清除波次关联 const existingWaveId = Number(existingOrder.wave_id || 0); const updateValues = { status: 'cancel', outbound_status: 'fin', step: 4, updated_at: new Date(), }; if (existingWaveId > 0) { updateValues.wave_id = 0; updateValues.wave_no = ''; } await existingOrder.update(updateValues, { transaction }); // 波次清理:删除波次索引、重建波次索引、更新波次统计 if (existingWaveId > 0) { await ctx.service.systemMethods.order.wave.deleteOrderWaveIndexByOrderIds({ warehouseId: info.warehouseId, orderIds: [ existingOrder.id ], transaction, }); // 重建受影响波次的订单索引(wave_index 重新排序) await ctx.service.systemMethods.order.wave.replaceOrderWaveIndexByWaveIds({ warehouseId: info.warehouseId, waveIds: [ existingWaveId ], orderModel: DeliveryModel, transaction, }); const { Op } = this.app.Sequelize; const WaveBatch = ctx.model.WaveBatch; if (WaveBatch) { await WaveBatch.decrement('total_orders', { by: 1, where: { wave_id: existingWaveId, warehouse_id: info.warehouseId, total_orders: { [Op.gt]: 0 }, }, transaction, }); const wave = await WaveBatch.findOne({ where: { wave_id: existingWaveId, warehouse_id: info.warehouseId }, attributes: [ 'wave_id', 'total_orders', 'wave_status' ], raw: true, transaction, }); if (wave) { const totalOrders = Number(wave.total_orders); const normalizedTotalOrders = Number.isFinite(totalOrders) ? totalOrders : 0; if (normalizedTotalOrders <= 0) { await WaveBatch.update( { total_orders: 0, wave_status: -1, update_time: new Date() }, { where: { wave_id: existingWaveId, warehouse_id: info.warehouseId }, transaction } ); } } } } // 释放储位分配锁定库存(wms_storage / wms_stock_warehouse) await this.releaseStorageLockForCancel({ orderId: existingOrder.id, warehouseId: info.warehouseId, transaction, }); await transaction.commit(); // 波次策略扫描清理(不影响主流程) if (existingWaveId > 0) { try { ctx.service.systemMethods.order.wave.enqueueWaveStrategyQuickScanPostOrderChange( info.warehouseId, [ existingOrder.id ], { triggerScan: true, source: 'qimenCancel' } ); } catch (scanErr) { ctx.logger.warn('[QimenOrderCancel] 波次策略扫描触发失败,不影响主流程', scanErr); } } // 写入取消操作日志(不影响主流程) 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} */ 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;