WMS_MAIN/app/service/systems/order_async.js
liufumingren 9845a239e2 1
2026-05-16 02:44:53 +08:00

1148 lines
38 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');
const CREATE_CHANNEL_QM = 'QM';
const CREATE_CHANNEL_MANUAL = 'MANUAL';
const CREATE_CHANNEL_API = 'API';
const RETRYABLE_DATABASE_ERROR_CODES = new Set([ 1205, 1213, 'ER_LOCK_WAIT_TIMEOUT', 'ER_LOCK_DEADLOCK' ]);
const TRANSACTION_LOCK_RETRY_MAX_ATTEMPTS = 3;
const TRANSACTION_LOCK_RETRY_BASE_DELAY_MS = 50;
function normalizeDatabaseErrorCodeInternal(error) {
const code = error && (error.code
|| (error.parent && error.parent.code)
|| error.errno
|| (error.parent && error.parent.errno)
|| null);
return typeof code === 'number' ? code : String(code || '').trim() || null;
}
function isRetryableTransactionLockErrorInternal(error) {
const code = normalizeDatabaseErrorCodeInternal(error);
const message = String((error && error.message) || (error && error.parent && error.parent.message) || '').toLowerCase();
return RETRYABLE_DATABASE_ERROR_CODES.has(code)
|| message.includes('deadlock found when trying to get lock')
|| message.includes('lock wait timeout');
}
async function runTransactionWithLockRetryInternal(service, tag, callback, attempt = 1) {
try {
return await service.ctx.model.transaction(async transaction => {
return await callback(transaction);
});
} catch (error) {
const retryable = isRetryableTransactionLockErrorInternal(error);
if (!retryable || attempt >= TRANSACTION_LOCK_RETRY_MAX_ATTEMPTS) {
throw error;
}
const code = normalizeDatabaseErrorCodeInternal(error) || 'UNKNOWN';
const message = String((error && error.message) || (error && error.parent && error.parent.message) || '').trim();
service.ctx.logger.warn(`[OrderAsyncService.${tag}] transaction lock retry attempt=${attempt} maxAttempts=${TRANSACTION_LOCK_RETRY_MAX_ATTEMPTS} code=${code} message=${message}`);
await new Promise(resolve => setTimeout(resolve, TRANSACTION_LOCK_RETRY_BASE_DELAY_MS * attempt));
return await runTransactionWithLockRetryInternal(service, tag, callback, attempt + 1);
}
}
function normalizeQimenResponseInternal(xmlArray) {
if (!xmlArray || typeof xmlArray !== 'object') {
return {};
}
const response = xmlArray.response || xmlArray;
if (Array.isArray(response)) {
return response[0] && typeof response[0] === 'object' ? response[0] : {};
}
return response && typeof response === 'object' ? response : {};
}
function resolveQimenSyncItemQuantityInternal(orderItem = {}) {
const actualQty = Number(orderItem.actual_qty);
if (Number.isFinite(actualQty) && actualQty > 0) {
return actualQty;
}
const planQty = Number(orderItem.plan_qty);
if (Number.isFinite(planQty) && planQty > 0) {
return planQty;
}
return 0;
}
function resolveOrderWaybillCodeInternal(orderRow = {}) {
return String(
orderRow.waybill_code
|| orderRow.express_code
|| orderRow.invoice_no
|| ''
).trim();
}
function resolveOrderWaybillCodesInternal(orderRow = {}, waybillCodes = []) {
const normalizedCodes = Array.isArray(waybillCodes)
? waybillCodes
.map(code => String(code || '').trim())
.filter(code => !!code)
: [];
if (normalizedCodes.length > 0) {
return normalizedCodes;
}
const fallbackCode = resolveOrderWaybillCodeInternal(orderRow);
return fallbackCode ? [ fallbackCode ] : [];
}
async function buildOrderWaybillCodeMapInternal(service, orderIds = []) {
const normalizedOrderIds = Array.isArray(orderIds)
? orderIds.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const waybillCodeMap = new Map();
const orderExpressModel = service.ctx.model && service.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.findAll !== 'function' || normalizedOrderIds.length === 0) {
return waybillCodeMap;
}
const { Op } = service.app.Sequelize;
const expressRows = await orderExpressModel.findAll({
where: {
order_id: {
[Op.in]: normalizedOrderIds,
},
},
attributes: [ 'order_id', 'business_key', 'waybill_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
});
for (const expressRow of Array.isArray(expressRows) ? expressRows : []) {
const orderId = Number(expressRow && expressRow.order_id);
const waybillCode = String(expressRow && expressRow.waybill_code || '').trim();
if (!Number.isFinite(orderId) || orderId <= 0 || !waybillCode) {
continue;
}
if (!waybillCodeMap.has(orderId)) {
waybillCodeMap.set(orderId, []);
}
waybillCodeMap.get(orderId).push(waybillCode);
}
return waybillCodeMap;
}
async function buildQimenDeliveryOrderConfirmDataInternal(service, orderRow, orderItems, requestContext = {}) {
const app = service.app;
const now = app.formatDate(new Date());
const firstItemOwnerCode = Array.isArray(orderItems)
? String((orderItems.find(item => item && String(item.owner_code || '').trim()) || {}).owner_code || '').trim()
: '';
const appKey = String(
requestContext.appKey
|| orderRow.from_key
|| ''
).trim();
const warehouseCodeHint = String(
requestContext.qimenWarehouseCode
|| requestContext.warehouseCode
|| orderRow.warehouse_code
|| ''
).trim();
const ownerCodeHint = String(
requestContext.customerId
|| requestContext.qimenOwnerCode
|| firstItemOwnerCode
|| ''
).trim();
let qimenContract = null;
if (appKey && ownerCodeHint && warehouseCodeHint && typeof service.findQimenAppWithContract === 'function') {
try {
qimenContract = await service.findQimenAppWithContract(appKey, ownerCodeHint, warehouseCodeHint);
} catch (error) {
service.ctx.logger.warn('[OrderAsyncService.buildQimenDeliveryOrderConfirmData] 读取奇门合同缓存失败', {
appKey,
customerId: ownerCodeHint,
warehouseCode: warehouseCodeHint,
message: error.message,
});
}
}
const ownerCode = String(
requestContext.customerId
|| requestContext.qimenOwnerCode
|| firstItemOwnerCode
|| (qimenContract && qimenContract.qimen_customer_id)
|| ''
).trim();
const warehouseCode = String(
requestContext.qimenWarehouseCode
|| requestContext.warehouseCode
|| orderRow.warehouse_code
|| (qimenContract && qimenContract.qimen_warehouse_code)
|| ''
).trim();
const packageExpressCode = String(
requestContext.packageExpressCode
|| orderRow.express_code
|| orderRow.waybill_code
|| ''
).trim();
const packageExpressCodeList = resolveOrderWaybillCodesInternal(orderRow, requestContext.packageExpressCodes);
const deliveryOrderCode = String(orderRow.delivery_order_code || '').trim();
const packageCode = String(orderRow.package_code || '').trim() || deliveryOrderCode;
const invoiceNo = String(orderRow.invoice_no || '').trim();
const orderConfirmTime = now;
const orderLines = [];
for (const orderItem of Array.isArray(orderItems) ? orderItems : []) {
const quantity = resolveQimenSyncItemQuantityInternal(orderItem);
if (quantity <= 0) {
continue;
}
orderLines.push({
orderLineNo: orderLines.length + 1,
orderSourceCode: String(orderItem.source_order_code || '').trim(),
subSourceCode: String(orderItem.sub_source_order_code || '').trim(),
ownerCode: String(orderItem.owner_code || ownerCode || '').trim(),
itemCode: String(orderItem.item_code || '').trim(),
itemId: Number(orderItem.item_id) || orderItem.item_id,
itemName: String(orderItem.item_name || '').trim(),
extCode: String(orderItem.ext_code || '').trim(),
planQty: Number(orderItem.plan_qty) || 0,
actualQty: quantity,
retailPrice: Number(orderItem.retail_price) || 0,
actualPrice: Number(orderItem.actual_price) || 0,
discountAmount: String(orderItem.discount_amount || '').trim(),
inventoryType: String(orderItem.inventory_type || '').trim(),
snList: Array.isArray(orderItem.sn_list) ? orderItem.sn_list.slice() : [],
qrCode: String(orderItem.qr_code || '').trim(),
});
}
return {
ownerCode,
warehouseCode,
request: {
deliveryOrder: {
totalOrderLines: orderLines.length,
deliveryOrderCode,
deliveryOrderId: Number(orderRow.id) || undefined,
warehouseCode,
orderType: String(orderRow.order_type || '').trim(),
status: 'DELIVERED',
outBizCode: deliveryOrderCode,
confirmType: 0,
orderConfirmTime,
operatorCode: '',
operatorName: '',
storageFee: String(orderRow.storage_fee || '').trim(),
operateTime: now,
},
packages: {
package: (packageExpressCodeList.length > 0 ? packageExpressCodeList : [ packageExpressCode ])
.filter(code => String(code || '').trim())
.map(expressCode => ({
logisticsCode: String(orderRow.logistics_code || '').trim(),
logisticsName: String(orderRow.logistics_name || '').trim(),
expressCode: String(expressCode || '').trim(),
packageCode,
invoiceNo,
})),
},
orderLines,
},
};
}
async function sendManualSyncNoticeInternal(service, syncResult = {}, context = {}) {
const rawNoticeService = service && service.ctx && service.ctx.service && service.ctx.service.systems && service.ctx.service.systems.notice;
const noticeService = rawNoticeService && typeof rawNoticeService.send === 'function'
? rawNoticeService
: (rawNoticeService && rawNoticeService.index && typeof rawNoticeService.index.send === 'function'
? rawNoticeService.index
: null);
if (!noticeService || typeof noticeService.send !== 'function') {
service.ctx.logger.error('[OrderAsyncService.sendManualSyncNotice] 通知服务不可用,通知失败', {
warehouseId: Number(context.warehouseId || syncResult.warehouse_id || 0),
orderIds: Array.isArray(syncResult.order_ids) ? syncResult.order_ids : [],
});
return {
success: false,
message: '通知服务不可用,通知失败',
data: null,
};
}
const payload = buildManualSyncNoticePayloadInternal(syncResult, context);
service.ctx.logger.info('[OrderAsyncService.sendManualSyncNotice] 调用通知服务前', {
event: payload.event,
businessName: payload.businessName,
warehouseId: payload.warehouseId,
storeId: payload.storeId,
orderIds: Array.isArray(syncResult.order_ids) ? syncResult.order_ids : [],
status: payload.metadata && payload.metadata.status,
routeState: payload.metadata && payload.metadata.route_state,
});
const noticeResult = await noticeService.send(payload);
service.ctx.logger.info('[OrderAsyncService.sendManualSyncNotice] 通知服务返回结果', {
event: payload.event,
businessName: payload.businessName,
warehouseId: payload.warehouseId,
orderIds: Array.isArray(syncResult.order_ids) ? syncResult.order_ids : [],
success: !!(noticeResult && noticeResult.success),
message: noticeResult && noticeResult.message,
data: noticeResult && noticeResult.data,
});
return noticeResult;
}
async function syncManualOrdersInternal(service, groupedOrder = {}, context = {}) {
const orderIds = Array.isArray(groupedOrder.order_ids)
? groupedOrder.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const warehouseId = Number(context.warehouseId || 0);
if (orderIds.length === 0) {
return {
create_channel: CREATE_CHANNEL_MANUAL,
order_ids: [],
order_count: 0,
warehouse_id: warehouseId,
handler: 'syncManualOrders',
sync_target: 'internal',
orders: [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: 'MANUAL 同步订单不能为空',
success_count: 0,
failed_count: 0,
};
}
if (warehouseId <= 0) {
return {
create_channel: CREATE_CHANNEL_MANUAL,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncManualOrders',
sync_target: 'internal',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: '缺少仓库上下文',
success_count: 0,
failed_count: orderIds.length,
};
}
const orderModel = await service.ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const orderItemsModel = await service.ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const { Op } = service.app.Sequelize;
const orderRows = await orderModel.findAll({
where: {
id: {
[Op.in]: orderIds,
},
warehouse_id: warehouseId,
},
raw: true,
});
const orderMap = new Map();
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
if (orderRow && Number(orderRow.id) > 0) {
orderMap.set(Number(orderRow.id), orderRow);
}
}
const waybillCodeMap = await buildOrderWaybillCodeMapInternal(service, orderIds);
const syncResults = await Promise.all(orderIds.map(orderId => {
return processManualOrderInternal(
service,
orderModel,
orderItemsModel,
orderId,
warehouseId,
orderMap.get(orderId),
context,
waybillCodeMap.get(orderId)
);
}));
const successCount = syncResults.filter(item => item.status === 'success').length;
const failedCount = syncResults.filter(item => item.status === 'failed').length;
const overallSuccess = failedCount === 0 && successCount === syncResults.length;
const firstFailedResult = syncResults.find(item => item.status === 'failed');
const aggregateNoticeResult = syncResults.length === 1
? syncResults[0] && syncResults[0].notice_result
: firstFailedResult && firstFailedResult.notice_result;
return {
create_channel: CREATE_CHANNEL_MANUAL,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncManualOrders',
sync_target: 'internal',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: syncResults,
route_state: overallSuccess ? 'accepted' : 'rejected',
status: overallSuccess ? 'success' : 'failed',
message: overallSuccess ? 'MANUAL 同步成功' : String(firstFailedResult && firstFailedResult.message || 'MANUAL 同步失败').trim() || 'MANUAL 同步失败',
success_count: successCount,
failed_count: failedCount,
notice_result: aggregateNoticeResult,
};
}
async function markPendingExceptionInternal(service, orderModel, orderId, warehouseId, exceptionText) {
const normalizedText = String(exceptionText || '').trim() || '订单同步失败';
const orderPendingExceptionService = service.ctx.service && service.ctx.service.systems && service.ctx.service.systems.orderPendingException;
if (orderPendingExceptionService && typeof orderPendingExceptionService.markPendingException === 'function') {
try {
return await orderPendingExceptionService.markPendingException({
id: orderId,
warehouse_id: warehouseId,
exception_text: normalizedText,
});
} catch (error) {
service.ctx.logger.warn('[OrderAsyncService.markPendingException] 复用异常服务失败,回退到直接更新', {
orderId,
warehouseId,
message: error.message,
});
}
}
await orderModel.update({
inspection_status: 'error',
step: 3,
order_flag: normalizedText,
updated_at: new Date(),
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
return {
success: true,
exception_text: normalizedText,
order_flag: normalizedText,
};
}
async function finalizeSuccessfulQimenSyncInternal(service, orderModel, orderItemsModel, orderId, warehouseId, orderRow = null) {
const stockStoreService = service.ctx.service && service.ctx.service.systems && service.ctx.service.systems.stockStore;
if (!service.ctx.model || typeof service.ctx.model.transaction !== 'function') {
throw new Error('事务能力未初始化');
}
if (!stockStoreService || typeof stockStoreService.outbound !== 'function') {
throw new Error('库存出库服务未初始化');
}
await runTransactionWithLockRetryInternal(service, 'finalizeSuccessfulQimenSync', async transaction => {
let resolvedOrderRow = orderRow;
if (!resolvedOrderRow && orderModel && typeof orderModel.findOne === 'function') {
resolvedOrderRow = await orderModel.findOne({
where: {
id: orderId,
warehouse_id: warehouseId,
},
attributes: [ 'id', 'delivery_order_code', 'order_type' ],
raw: true,
transaction,
});
}
const outboundMetaOrderId = Number(resolvedOrderRow && resolvedOrderRow.id) || Number(orderId) || null;
const outboundMetaOrderNo = String(resolvedOrderRow && resolvedOrderRow.delivery_order_code || '').trim() || null;
const freshOrderItems = await orderItemsModel.findAll({
where: {
order_id: orderId,
},
raw: true,
transaction,
});
for (const orderItem of Array.isArray(freshOrderItems) ? freshOrderItems : []) {
const itemId = Number(orderItem && orderItem.item_id);
const quantity = resolveQimenSyncItemQuantityInternal(orderItem);
if (!Number.isFinite(itemId) || itemId <= 0 || quantity <= 0) {
continue;
}
const outboundOrderItemId = Number(orderItem && (orderItem.id || orderItem.order_item_id)) || null;
const outboundResult = await stockStoreService.outbound(itemId, quantity, transaction, {
orderId: outboundMetaOrderId,
orderNo: outboundMetaOrderNo,
orderItemId: outboundOrderItemId,
});
if (!outboundResult || outboundResult.success !== true) {
throw new Error(String(outboundResult && outboundResult.error || `订单${orderId}库存扣减失败`).trim());
}
}
await orderModel.update({
sync_status: 'fin',
inspection_status: 'padding',
step: 2,
order_flag: '',
updated_at: new Date(),
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
transaction,
});
});
}
async function processLocalChannelOrderInternal(service, createChannel, orderModel, orderItemsModel, orderId, warehouseId, orderRow) {
if (!orderRow) {
return {
order_id: orderId,
status: 'failed',
message: '发货单不存在',
};
}
try {
await runTransactionWithLockRetryInternal(service, 'processLocalChannelOrder', async transaction => {
const freshOrderItems = await orderItemsModel.findAll({
where: {
order_id: orderId,
},
raw: true,
transaction,
});
for (const orderItem of Array.isArray(freshOrderItems) ? freshOrderItems : []) {
const itemId = Number(orderItem && orderItem.item_id);
const quantity = resolveQimenSyncItemQuantityInternal(orderItem);
if (!Number.isFinite(itemId) || itemId <= 0 || quantity <= 0) {
continue;
}
const outboundOrderItemId = Number(orderItem && (orderItem.id || orderItem.order_item_id)) || null;
const outboundResult = await service.ctx.service.systems.stockStore.outbound(itemId, quantity, transaction, {
orderId: Number(orderRow && orderRow.id) || Number(orderId) || null,
orderNo: String(orderRow && orderRow.delivery_order_code || '').trim() || null,
orderItemId: outboundOrderItemId,
});
if (!outboundResult || outboundResult.success !== true) {
throw new Error(String(outboundResult && outboundResult.error || `订单${orderId}库存扣减失败`).trim());
}
}
await orderModel.update({
sync_status: 'fin',
inspection_status: 'padding',
step: 2,
order_flag: '',
updated_at: new Date(),
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
transaction,
});
});
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'success',
message: `${createChannel} 同步成功`,
};
} catch (error) {
await orderModel.update({
sync_status: 'error',
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, error.message || `${createChannel} 同步后库存扣减失败`);
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: error.message || `${createChannel} 同步后库存扣减失败`,
error: error.message,
};
}
}
async function processManualOrderInternal(service, orderModel, orderItemsModel, orderId, warehouseId, orderRow, context = {}, waybillCodes = []) {
if (!orderRow) {
return {
order_id: orderId,
status: 'failed',
message: '发货单不存在',
};
}
const resolvedWaybillCodes = resolveOrderWaybillCodesInternal(orderRow, waybillCodes);
const noticeSyncResult = {
create_channel: CREATE_CHANNEL_MANUAL,
order_ids: [ orderId ],
order_count: 1,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
waybill_code: resolvedWaybillCodes,
warehouse_id: warehouseId,
handler: 'syncManualOrders',
sync_target: 'internal',
route_state: 'accepted',
status: 'success',
message: '订单同步通知已发送',
success_count: 1,
failed_count: 0,
};
const noticeResult = await sendManualSyncNoticeInternal(service, noticeSyncResult, context);
if (!noticeResult || noticeResult.success !== true) {
const noticeMessage = String(noticeResult && noticeResult.message || '通知发送失败').trim() || '通知发送失败';
await orderModel.update({
sync_status: 'error',
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, noticeMessage);
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: noticeMessage,
error: noticeMessage,
notice_result: noticeResult || {
success: false,
message: noticeMessage,
data: null,
},
};
}
const localSyncResult = await processLocalChannelOrderInternal(
service,
CREATE_CHANNEL_MANUAL,
orderModel,
orderItemsModel,
orderId,
warehouseId,
orderRow
);
return {
...localSyncResult,
notice_result: noticeResult,
};
}
async function finalizeLocalChannelOrdersInternal(service, createChannel, groupedOrder = {}, context = {}, syncTarget = 'internal') {
const orderIds = Array.isArray(groupedOrder.order_ids)
? groupedOrder.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const warehouseId = Number(context.warehouseId || 0);
if (orderIds.length === 0) {
return {
create_channel: createChannel,
order_ids: [],
order_count: 0,
warehouse_id: warehouseId,
handler: createChannel === CREATE_CHANNEL_MANUAL ? 'syncManualOrders' : 'syncApiOrders',
sync_target: syncTarget,
orders: [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: `${createChannel} 同步订单不能为空`,
success_count: 0,
failed_count: 0,
};
}
if (warehouseId <= 0) {
return {
create_channel: createChannel,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: createChannel === CREATE_CHANNEL_MANUAL ? 'syncManualOrders' : 'syncApiOrders',
sync_target: syncTarget,
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: '缺少仓库上下文',
success_count: 0,
failed_count: orderIds.length,
};
}
const orderModel = await service.ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const orderItemsModel = await service.ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const { Op } = service.app.Sequelize;
const [ orderRows, orderItemRows ] = await Promise.all([
orderModel.findAll({
where: {
id: {
[Op.in]: orderIds,
},
warehouse_id: warehouseId,
},
raw: true,
}),
orderItemsModel.findAll({
where: {
order_id: {
[Op.in]: orderIds,
},
},
raw: true,
}),
]);
const orderMap = new Map();
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
if (orderRow && Number(orderRow.id) > 0) {
orderMap.set(Number(orderRow.id), orderRow);
}
}
void orderItemRows;
const syncResults = await Promise.all(orderIds.map(orderId => {
return processLocalChannelOrderInternal(
service,
createChannel,
orderModel,
orderItemsModel,
orderId,
warehouseId,
orderMap.get(orderId)
);
}));
const successCount = syncResults.filter(item => item.status === 'success').length;
const failedCount = syncResults.filter(item => item.status === 'failed').length;
const overallSuccess = failedCount === 0 && successCount === syncResults.length;
return {
create_channel: createChannel,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: createChannel === CREATE_CHANNEL_MANUAL ? 'syncManualOrders' : 'syncApiOrders',
sync_target: syncTarget,
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: syncResults,
route_state: overallSuccess ? 'accepted' : 'rejected',
status: overallSuccess ? 'success' : 'failed',
message: overallSuccess ? `${createChannel} 同步成功` : `${createChannel} 同步失败`,
success_count: successCount,
failed_count: failedCount,
};
}
function buildManualSyncNoticePayloadInternal(syncResult = {}, context = {}) {
const orderIds = Array.isArray(syncResult.order_ids)
? syncResult.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const warehouseId = Number(context.warehouseId || syncResult.warehouse_id || 0);
const noticeMessage = String(syncResult.message || '').trim() || '订单同步完成';
const noticeStatus = String(syncResult.status || '').trim() || 'success';
const deliveryOrderCode = String(syncResult.delivery_order_code || '').trim();
const waybillCodeList = Array.isArray(syncResult.waybill_code)
? syncResult.waybill_code.map(code => String(code || '').trim()).filter(code => !!code)
: (Array.isArray(syncResult.waybill_code_list)
? syncResult.waybill_code_list.map(code => String(code || '').trim()).filter(code => !!code)
: (String(syncResult.waybill_code || '').trim() ? [ String(syncResult.waybill_code || '').trim() ] : []));
return {
event: 'order_sync_completed',
businessName: 'order',
warehouseId,
storeId: Number(context.storeId || context.warehouseId || 0),
subject: {
id: warehouseId,
type: 'warehouse',
},
title: '订单同步完成',
message: [
`仓库ID:${warehouseId || '未知'}`,
`订单ID:${orderIds.join(',') || '无'}`,
`发货单号:${deliveryOrderCode || '无'}`,
`运单号:${waybillCodeList.length > 0 ? waybillCodeList.join(',') : '无'}`,
`消息:${noticeMessage}`,
].join('\n'),
metadata: {
create_channel: CREATE_CHANNEL_MANUAL,
sync_target: 'internal',
order_ids: orderIds,
delivery_order_code: deliveryOrderCode,
waybill_code: waybillCodeList,
order_count: Number.isFinite(Number(syncResult.order_count)) ? Number(syncResult.order_count) : orderIds.length,
status: noticeStatus,
route_state: String(syncResult.route_state || '').trim(),
success_count: Number(syncResult.success_count || 0),
failed_count: Number(syncResult.failed_count || 0),
},
};
}
async function processQmOrderInternal(service, orderModel, orderItemsModel, qimenClient, orderId, warehouseId, orderRow, orderItems, context, waybillCode) {
if (!orderRow) {
return {
order_id: orderId,
status: 'failed',
message: '发货单不存在',
qimen_flag: 'failure',
};
}
if (!qimenClient || typeof qimenClient.send !== 'function') {
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, '奇门客户端未初始化');
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: '奇门客户端未初始化',
qimen_flag: 'failure',
};
}
const requestData = await buildQimenDeliveryOrderConfirmDataInternal(service, orderRow, orderItems, {
...context,
packageExpressCode: Array.isArray(waybillCode) ? waybillCode[0] : (waybillCode || orderRow.express_code || ''),
packageExpressCodes: Array.isArray(waybillCode) ? waybillCode : [],
});
if (!requestData.ownerCode) {
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, '发货单缺少奇门货主编码');
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: '发货单缺少奇门货主编码',
qimen_flag: 'failure',
};
}
service.ctx.logger.info('[OrderAsyncService.syncQmOrders] 奇门请求参数', {
orderId,
deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(),
ownerCode: requestData.ownerCode,
warehouseCode: requestData.warehouseCode,
totalOrderLines: requestData.request.deliveryOrder.totalOrderLines,
deliveryOrder: requestData.request.deliveryOrder,
package: requestData.request.packages,
orderLinesCount: Array.isArray(requestData.request.orderLines)
? requestData.request.orderLines.length
: 0,
});
let sendResult;
try {
sendResult = await qimenClient.send('taobao.qimen.deliveryorder.confirm', requestData.ownerCode, requestData.request, {
ctx: service.ctx,
});
} catch (error) {
await orderModel.update({
sync_status: 'error',
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, error.message || '奇门发货单确认失败');
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: error.message || '奇门发货单确认失败',
qimen_flag: 'failure',
error: error.message,
};
}
const response = normalizeQimenResponseInternal(sendResult.xmlArray);
service.ctx.logger.info('[OrderAsyncService.syncQmOrders] 奇门返回结果', {
orderId,
deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(),
qimenQueryId: sendResult.queryId || null,
rawXmlArray: sendResult.xmlArray,
normalizedResponse: response,
});
const isSuccess = String(response.flag || '').trim() === 'success';
if (isSuccess) {
try {
await finalizeSuccessfulQimenSyncInternal(service, orderModel, orderItemsModel, orderId, warehouseId, orderRow);
} catch (error) {
await orderModel.update({
sync_status: 'error',
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, error.message || '奇门发货单确认后库存扣减失败');
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: 'failed',
message: error.message || '奇门发货单确认后库存扣减失败',
qimen_flag: 'failure',
qimen_code: 'LOCAL_STOCK_ERROR',
qimen_message: error.message || '奇门发货单确认后库存扣减失败',
qimen_query_id: sendResult.queryId || null,
};
}
} else {
await orderModel.update({
sync_status: 'error',
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
},
});
}
const result = {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
status: isSuccess ? 'success' : 'failed',
message: String(response.message || '').trim() || (isSuccess ? '奇门发货单确认成功' : '奇门发货单确认失败'),
qimen_flag: String(response.flag || '').trim(),
qimen_code: String(response.code || '').trim(),
qimen_message: String(response.message || '').trim(),
qimen_query_id: sendResult.queryId || null,
};
if (!isSuccess) {
await markPendingExceptionInternal(
service,
orderModel,
orderId,
warehouseId,
String(response.message || response.code || '奇门发货单确认失败').trim() || '奇门发货单确认失败'
);
}
return result;
}
async function syncQmOrdersInternal(service, groupedOrder = {}, context = {}) {
const orderIds = Array.isArray(groupedOrder.order_ids)
? groupedOrder.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const warehouseId = Number(context.warehouseId || 0);
if (orderIds.length === 0) {
return {
create_channel: CREATE_CHANNEL_QM,
order_ids: [],
order_count: 0,
warehouse_id: warehouseId,
handler: 'syncQmOrders',
sync_target: 'qimen',
orders: [],
qimen_results: [],
route_state: 'rejected',
status: 'failed',
message: 'QM 同步订单不能为空',
};
}
if (warehouseId <= 0) {
return {
create_channel: CREATE_CHANNEL_QM,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncQmOrders',
sync_target: 'qimen',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
qimen_results: [],
route_state: 'rejected',
status: 'failed',
message: '缺少仓库上下文',
};
}
const orderModel = await service.ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const orderItemsModel = await service.ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const { Op } = service.app.Sequelize;
const [ orderRows, orderItemRows ] = await Promise.all([
orderModel.findAll({
where: {
id: {
[Op.in]: orderIds,
},
warehouse_id: warehouseId,
},
raw: true,
}),
orderItemsModel.findAll({
where: {
order_id: {
[Op.in]: orderIds,
},
},
raw: true,
}),
]);
const orderMap = new Map();
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
if (orderRow && Number(orderRow.id) > 0) {
orderMap.set(Number(orderRow.id), orderRow);
}
}
const waybillCodeMap = await buildOrderWaybillCodeMapInternal(service, orderIds);
const itemsByOrderId = new Map();
for (const orderItem of Array.isArray(orderItemRows) ? orderItemRows : []) {
const orderId = Number(orderItem && orderItem.order_id);
if (!Number.isFinite(orderId) || orderId <= 0) {
continue;
}
if (!itemsByOrderId.has(orderId)) {
itemsByOrderId.set(orderId, []);
}
itemsByOrderId.get(orderId).push(orderItem);
}
const qimenClient = service.app.qimenClient;
const qimenResults = await Promise.all(orderIds.map(orderId => {
return processQmOrderInternal(
service,
orderModel,
orderItemsModel,
qimenClient,
orderId,
warehouseId,
orderMap.get(orderId),
itemsByOrderId.get(orderId) || [],
context,
waybillCodeMap.get(orderId)
);
}));
const successCount = qimenResults.filter(item => item.status === 'success').length;
const failedCount = qimenResults.filter(item => item.status === 'failed').length;
const overallSuccess = failedCount === 0 && successCount === qimenResults.length;
return {
create_channel: CREATE_CHANNEL_QM,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncQmOrders',
sync_target: 'qimen',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
qimen_results: qimenResults,
route_state: overallSuccess ? 'accepted' : 'rejected',
status: overallSuccess ? 'success' : 'failed',
message: overallSuccess ? '奇门发货单确认成功' : '奇门发货单确认失败',
success_count: successCount,
failed_count: failedCount,
};
}
/**
* 订单异步同步路由服务。
*/
class OrderAsyncService extends MainService {
async finalizeSuccessfulQimenSync(orderModel, orderItemsModel, orderId, warehouseId, orderRow = null) {
return await finalizeSuccessfulQimenSyncInternal(this, orderModel, orderItemsModel, orderId, warehouseId, orderRow);
}
/**
* QM 创建入口处理。
*
* @param {Object} groupedOrder 分组后的订单。
* @param {Object} context 上下文。
* @return {Promise<Object>} 处理结果。
*/
async syncQmOrders(groupedOrder = {}, context = {}) {
return await syncQmOrdersInternal(this, groupedOrder, context);
}
/**
* MANUAL 创建入口处理。
*
* @param {Object} groupedOrder 分组后的订单。
* @param {Object} context 上下文。
* @return {Promise<Object>} 处理结果。
*/
async syncManualOrders(groupedOrder = {}, context = {}) {
return await syncManualOrdersInternal(this, groupedOrder, context);
}
/**
* API 创建入口处理。
*
* @param {Object} groupedOrder 分组后的订单。
* @param {Object} context 上下文。
* @return {Promise<Object>} 处理结果。
*/
async syncApiOrders(groupedOrder = {}, context = {}) {
return await finalizeLocalChannelOrdersInternal(this, CREATE_CHANNEL_API, groupedOrder, context, 'api');
}
}
module.exports = OrderAsyncService;