2239 lines
83 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');
const DEFAULT_CACHE_TTL_SECONDS = 600;
const DEFAULT_EXPRESS_PRODUCT_TYPE_CACHE_TTL_SECONDS = 60 * 60;
const DEFAULT_WAYBILL_BATCH_SIZE = 10;
const WAYBILL_EXCEPTION_STEP = 3;
const WAYBILL_ORDER_DELIVERY_MIN_ATTRIBUTES = Object.freeze([
'id',
'store_id',
'warehouse_id',
'delivery_order_code',
'source_platform_code',
'source_platform_name',
'sys_platform_code',
'sys_platform_name',
'order_type',
'status',
'post_status',
'step',
'order_flag',
'from_key',
'create_at',
'place_order_time',
'pay_time',
'operate_time',
'delivery_time',
'name',
'tel',
'mobile',
'email',
'country_code',
'province',
'city',
'area',
'town',
'detail_address',
'zip_code',
'total_amount',
'item_amount',
'discount_amount',
'freight',
'ar_amount',
'got_amount',
'items',
'items_count',
'items_total',
'items_weight',
'logistics_name',
'sys_logistics_code',
'sys_logistics_name',
'express_code',
'logistics_area_code',
'oaid',
'source_order_codes',
'logistics_code',
]);
class ExpressService extends Service {
/**
* 生成快递列表缓存键。
*
* @param {number|string} warehouseId 仓库ID
* @param {boolean} [systemOnly=false] 是否仅返回系统基础快递列表
* @return {string} 缓存键
*/
getExpressListCacheKey(warehouseId = 0, systemOnly = false) {
if (systemOnly) {
return 'express:list:system';
}
const normalizedWarehouseId = Number(warehouseId || 0);
if (Number.isFinite(normalizedWarehouseId) && normalizedWarehouseId > 0) {
return `express:list:${normalizedWarehouseId}`;
}
return 'express:list';
}
/**
* 获取当前上下文中的仓库ID。
*
* @return {number} 仓库ID,未获取到时返回 0
*/
getCurrentWarehouseId() {
const warehouseId = Number(this.ctx && this.ctx.user && this.ctx.user.store_id || 0);
if (Number.isFinite(warehouseId) && warehouseId > 0) {
return warehouseId;
}
return 0;
}
/**
* 构建快递号分配链路追踪ID。
*
* 优先使用入参中的 trace_id/traceId,其次读取上下文 trace 信息,最后兜底生成。
*
* @param {Object} [data={}] 入参。
* @param {string} [fallback=''] 兜底标识。
* @return {string} 追踪ID。
*/
buildWaybillTraceId(data = {}, fallback = '') {
const normalizedData = data && typeof data === 'object' ? data : {};
const ctxTraceId = this.ctx && this.ctx.traceId !== undefined
? this.ctx.traceId
: this.ctx && this.ctx.requestId !== undefined
? this.ctx.requestId
: this.ctx && this.ctx.state && this.ctx.state.traceId !== undefined
? this.ctx.state.traceId
: '';
const normalizedTraceId = String(
normalizedData.trace_id
|| normalizedData.traceId
|| ctxTraceId
|| fallback
|| ''
).trim();
if (normalizedTraceId) {
return normalizedTraceId;
}
return `waybill_trace_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
}
/**
* 获取订单日志使用的操作人信息。
*
* 取值优先级:employees_id/employees_name -> operator_id/operator_name -> id/real_name/name。
*
* @return {{ id: string|null, name: string }} 操作人信息。
*/
getOrderLogOperator() {
const stateUser = this.ctx && this.ctx.state && this.ctx.state.user && typeof this.ctx.state.user === 'object'
? this.ctx.state.user
: null;
const ctxUser = this.ctx && this.ctx.user && typeof this.ctx.user === 'object'
? this.ctx.user
: null;
const operatorSource = stateUser || ctxUser || {};
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
const rawOperatorName = operatorSource.employees_name
?? operatorSource.operator_name
?? operatorSource.real_name
?? operatorSource.name;
const operatorId = rawOperatorId === undefined || rawOperatorId === null
? null
: String(rawOperatorId).trim() || null;
const operatorName = rawOperatorName === undefined || rawOperatorName === null
? 'system'
: String(rawOperatorName).trim() || 'system';
return {
id: operatorId,
name: operatorName,
};
}
/**
* 获取订单日志使用的仓库ID。
*
* @param {number|string|null} [preferredWarehouseId=null] 优先仓库ID。
* @return {number|string|null} 仓库ID。
*/
getOrderLogWarehouseId(preferredWarehouseId = null) {
const candidates = [
preferredWarehouseId,
this.getCurrentWarehouseId(),
this.ctx && this.ctx.user ? this.ctx.user.warehouse_id : null,
this.ctx && this.ctx.user ? this.ctx.user.store_id : null,
];
for (const candidate of candidates) {
if (candidate === undefined || candidate === null || candidate === '') {
continue;
}
return candidate;
}
return null;
}
/**
* 为分配快递失败订单写入订单操作日志。
*
* @param {Array<number|string>} orderIds 订单ID数组。
* @param {string} errorMessage 失败原因。
* @param {number|string|null} warehouseId 仓库ID。
* @return {Promise<void>} 无返回值。
*/
async createAllocateExpressFailureLogs(orderIds = [], errorMessage = '', warehouseId = null) {
const operationLogService = this.service
&& this.service.systems
&& this.service.systems.operationLog;
if (!operationLogService || typeof operationLogService.createOperationLogs !== 'function') {
return;
}
const operator = this.getOrderLogOperator();
const normalizedWarehouseId = this.getOrderLogWarehouseId(warehouseId);
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
.map(orderId => Number(orderId))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)));
const normalizedErrorMessage = String(errorMessage || '').trim() || '未知异常';
const payloads = normalizedOrderIds.map(orderId => ({
businessType: 'order',
businessId: String(orderId),
operationCode: 'ORDER_EXPRESS_ALLOCATE_FAILED',
operator,
extras: {
message: `分配快递失败:${normalizedErrorMessage}`,
warehouseId: normalizedWarehouseId,
externalLogType: 'API',
},
}));
await operationLogService.createOperationLogs(payloads);
}
/**
* 将 business_key 规范化为内部可处理的正整数列表。
*【已使用】
* @param {*} businessKey 原始 business_key 值。
* @return {Array<number>} 正整数业务键列表。
*/
normalizeWaybillBusinessKeys(businessKey = null) {
const rawBusinessKeys = Array.isArray(businessKey)
? businessKey.flat(Infinity)
: [ businessKey ];
const normalizedBusinessKeys = [];
const seenBusinessKeys = new Set();
for (const rawBusinessKey of rawBusinessKeys) {
const normalizedBusinessKey = Number(rawBusinessKey);
if (!Number.isInteger(normalizedBusinessKey) || normalizedBusinessKey <= 0 || seenBusinessKeys.has(normalizedBusinessKey)) {
continue;
}
seenBusinessKeys.add(normalizedBusinessKey);
normalizedBusinessKeys.push(normalizedBusinessKey);
}
return normalizedBusinessKeys;
}
/**
* 规范化运单创建时携带的平台上下文编码。
*
* 该值仅作为异步后处理的辅助上下文,不参与主流程分组与去重。
*【已使用】
* @param {Object} order 原始订单。
* @return {string} 平台编码,小写。
*/
normalizeWaybillCreatePlatformCode(order = {}) {
if (!order || typeof order !== 'object') {
return '';
}
const expressPlatform = order.wms_express_platform && typeof order.wms_express_platform === 'object'
? order.wms_express_platform
: (order.wmsExpressPlatform && typeof order.wmsExpressPlatform === 'object' ? order.wmsExpressPlatform : null);
const rawPlatformCode = (expressPlatform && (expressPlatform.platform_code || expressPlatform.platformCode))
|| (typeof order.wms_express_platform === 'string' ? order.wms_express_platform : '')
|| (typeof order.wmsExpressPlatform === 'string' ? order.wmsExpressPlatform : '')
|| order.platform_code
|| order.platformCode
|| order.express_platform_code
|| order.expressPlatformCode
|| '';
return String(rawPlatformCode).trim().toLowerCase();
}
/**
* 规范化运单余额相关策略配置。
*
* @param {*} policyConfig 策略配置。
* @return {Object} 规范化后的策略配置对象。
*/
normalizeWaybillPolicyConfig(policyConfig) {
const storeWarehouseModel = this.ctx.model && this.ctx.model.StoreWarehouse;
if (storeWarehouseModel && typeof storeWarehouseModel.normalizePolicyConfig === 'function') {
try {
return storeWarehouseModel.normalizePolicyConfig(policyConfig, {
fieldName: 'policy_config',
allowEmpty: true,
sanitizeOnly: true,
}) || {};
} catch (error) {
this.ctx.logger.warn('[ExpressService.normalizeWaybillPolicyConfig] policy_config 解析失败: %s', error.message);
return {};
}
}
if (policyConfig && typeof policyConfig === 'object' && !Array.isArray(policyConfig)) {
return policyConfig;
}
if (typeof policyConfig !== 'string') {
return {};
}
try {
const parsedConfig = JSON.parse(policyConfig);
if (parsedConfig && typeof parsedConfig === 'object' && !Array.isArray(parsedConfig)) {
return parsedConfig;
}
} catch (error) {
this.ctx.logger.warn('[ExpressService.normalizeWaybillPolicyConfig] policy_config 解析失败: %s', error.message);
}
return {};
}
/**
* 生成运单余额不足的异常文案。
*
* @param {Object} options 文案参数。
* @param {number} options.availableQuantity 当前可用余额。
* @param {number} options.requestedQuantity 本次请求数量。
* @param {number} options.shortageQuantity 不足数量。
* @param {number} options.expressQuota 快递额度。
* @param {number} options.usedQuantity 已用额度。
* @return {string} 异常文案。
*/
buildWaybillBalanceExceptionText({
availableQuantity = 0,
requestedQuantity = 0,
shortageQuantity = 0,
expressQuota = 0,
usedQuantity = 0,
} = {}) {
return `货主快递余额不足:余额 ${Math.max(0, Number(usedQuantity) || 0) + Math.max(0, Number(availableQuantity) || 0)},已用 ${Math.max(0, Number(usedQuantity) || 0)},可用 ${Math.max(0, Number(availableQuantity) || 0)},额度 ${Math.max(0, Number(expressQuota) || 0)},需要 ${Math.max(0, Number(requestedQuantity) || 0)},不足 ${Math.max(0, Number(shortageQuantity) || 0)}`;
}
/**
* 规范化运单创建入参并按订单与业务键去重。
*
* 仅当输入已经完成基础规整时,直接做最小必要校验与去重;
* 如果还保留数组业务键或缺失主字段,则回退到完整规整流程。
*【已使用】
* @param {Array<Object>} orders 原始运单创建入参,business_key 可为单值或数组。
* @return {Array<Object>} 规范化后的订单列表。
*/
async normalizeWaybillCreateOrders(orders = []) {
const normalizedOrders = Array.isArray(orders) ? orders : [];
const normalizedOrderMap = new Map();
await this.loadExpressList();
for (const order of normalizedOrders) {
if (!order || typeof order !== 'object') {
continue;
}
const orderId = Number(order.id || order.order_id);
const businessKeys = this.normalizeWaybillBusinessKeys(order.business_key);
if (!Number.isInteger(orderId) || orderId <= 0 || businessKeys.length === 0) {
continue;
}
const sysPlatformCode = String(order.sys_platform_code || order.sysPlatformCode || '').trim();
const logisticsCode = String(order.logistics_code || order.logisticsCode || '').trim();
const syslogisticsCode = String(order.sys_logistics_code || order.sysLogisticsCode || '').trim();
const platformCode = this.normalizeWaybillCreatePlatformCode(order);
for (const businessKey of businessKeys) {
const orderKey = `${orderId}:${businessKey}`;
if (normalizedOrderMap.has(orderKey)) {
continue;
}
normalizedOrderMap.set(orderKey, {
order_id: orderId,
business_key: businessKey,
...(sysPlatformCode ? { sys_platform_code: sysPlatformCode } : {}),
...(logisticsCode ? { logistics_code: logisticsCode } : {}),
...(platformCode ? { platform_code: platformCode } : {}),
});
}
}
return Array.from(normalizedOrderMap.values());
}
/**
* 根据订单主表记录构建签约关系分组,并标记缺失订单。
*【已使用】
* @param {Array<Object>} normalizedOrders 规范化后的订单列表。
* @param {Array<Object>} orderDeliveryRows 订单主表查询结果。
* @param {number} currentWarehouseId 当前仓库 ID。
* @return {Object} 分组结果,包含 relationGroupMap 和 missingOrderIds。
*/
buildWaybillCreateRelationGroups(normalizedOrders = [], orderDeliveryRows = [], currentWarehouseId = 0) {
const orderDeliveryMap = new Map();
for (const row of Array.isArray(orderDeliveryRows) ? orderDeliveryRows : []) {
const orderId = Number(row && row.id);
if (Number.isFinite(orderId) && orderId > 0) {
orderDeliveryMap.set(orderId, row);
}
}
const relationGroupMap = new Map();
const missingOrderIds = [];
for (const order of Array.isArray(normalizedOrders) ? normalizedOrders : []) {
const orderRow = orderDeliveryMap.get(order.order_id);
if (!orderRow) {
missingOrderIds.push(order.order_id);
continue;
}
const storeId = Number(orderRow.store_id || 0);
const warehouseId = Number(orderRow.warehouse_id || currentWarehouseId);
if (!Number.isFinite(storeId) || storeId <= 0 || !Number.isFinite(warehouseId) || warehouseId <= 0) {
missingOrderIds.push(order.order_id);
continue;
}
const relationKey = `${storeId}:${warehouseId}`;
let relationGroup = relationGroupMap.get(relationKey);
if (!relationGroup) {
relationGroup = {
store_id: storeId,
warehouse_id: warehouseId,
orders: [],
};
relationGroupMap.set(relationKey, relationGroup);
}
relationGroup.orders.push({
...order,
store_id: storeId,
warehouse_id: warehouseId,
});
}
return {
relationGroupMap,
missingOrderIds,
};
}
/**
* 处理签约关系分组中的可创建与失败订单。
*【已使用】
* @param {Map<string, Object>} relationGroupMap 签约关系分组。
* @param {Map<string, Object>} relationMap 签约关系记录映射。
* @return {Promise<Object>} 处理结果,包含 successOrderKeySet、failedOrdersByReason 和 balanceWarnings。
*/
async collectWaybillRelationProcessingState(relationGroupMap, relationMap) {
const successOrderKeySet = new Set();
const failedOrdersByReason = new Map();
const balanceWarnings = [];
for (const relationGroup of relationGroupMap.values()) {
const relationKey = `${relationGroup.store_id}:${relationGroup.warehouse_id}`;
const relation = relationMap.get(relationKey);
if (!relation) {
const exceptionText = '签约关系不存在,无法创建运单';
const failedOrderIds = relationGroup.orders.map(order => order.order_id);
failedOrdersByReason.set(exceptionText, (failedOrdersByReason.get(exceptionText) || []).concat(failedOrderIds));
continue;
}
const policyConfig = this.normalizeWaybillPolicyConfig(relation.policy_config);
const expressQuota = Math.max(0, Number(policyConfig.express_quota || 0) || 0);
const requestCount = relationGroup.orders.length;
const currentPrintQuantity = Number(relation.print_quantity || 0);
const currentLockedQuantity = Number(relation.print_quantity_locked || 0);
const availableQuantity = currentPrintQuantity - currentLockedQuantity;
const allowedQuantity = Math.max(0, availableQuantity + expressQuota);
const successCount = Math.min(requestCount, allowedQuantity);
const failedCount = requestCount - successCount;
const successOrders = relationGroup.orders.slice(0, successCount);
const failedOrders = relationGroup.orders.slice(successCount);
this.ctx.logger.info(`[waybill-balance] store_id=${relation.store_id} warehouse_id=${relation.warehouse_id} print_quantity=${currentPrintQuantity} print_quantity_locked=${currentLockedQuantity} availableQuantity=${availableQuantity} expressQuota=${expressQuota} allowedQuantity=${allowedQuantity} requestCount=${requestCount} successCount=${successCount} failedCount=${failedCount}`);
for (const order of successOrders) {
successOrderKeySet.add(`${order.order_id}:${order.business_key}`);
}
if (failedCount > 0) {
const exceptionText = this.buildWaybillBalanceExceptionText({
availableQuantity,
requestedQuantity: requestCount,
shortageQuantity: failedCount,
expressQuota,
usedQuantity: Math.max(0, currentLockedQuantity),
});
const failedOrderIds = failedOrders.map(order => order.order_id);
failedOrdersByReason.set(exceptionText, (failedOrdersByReason.get(exceptionText) || []).concat(failedOrderIds));
}
}
return {
successOrderKeySet,
failedOrdersByReason,
balanceWarnings,
};
}
/**
* 根据成功订单、订单主表快照和已存在快递记录,统计需要新增锁定的余额数量。
*
* 只统计真正会进入 `rowsToCreate` 的记录,避免把已存在且状态不同的记录重复计入。
*
* @param {Array<Object>} successOrders 成功订单列表。
* @param {Map<number, Object>} orderDeliveryMap 订单主表快照映射。
* @param {Map<string, Object>} existingMap 已存在快递记录映射。
* @return {Map<string, Object>} 关系分组锁定统计。
*/
buildWaybillRelationLockMap(successOrders = [], orderDeliveryMap = new Map(), existingMap = new Map()) {
const relationLockMap = new Map();
for (const order of Array.isArray(successOrders) ? successOrders : []) {
const orderKey = `${order.order_id}:${order.business_key}`;
if (existingMap.has(orderKey)) {
continue;
}
const orderDelivery = orderDeliveryMap.get(Number(order.order_id));
const storeId = Number(orderDelivery && orderDelivery.store_id) || 0;
const warehouseId = Number(orderDelivery && orderDelivery.warehouse_id) || 0;
if (!Number.isFinite(storeId) || storeId <= 0 || !Number.isFinite(warehouseId) || warehouseId <= 0) {
continue;
}
const relationKey = `${storeId}:${warehouseId}`;
const currentRelationLock = relationLockMap.get(relationKey) || {
store_id: storeId,
warehouse_id: warehouseId,
locked_quantity: 0,
};
currentRelationLock.locked_quantity += 1;
relationLockMap.set(relationKey, currentRelationLock);
}
return relationLockMap;
}
/**
* 按店铺和仓库分组锁定新增的运单余额。
*
* @param {Map<string, Object>} relationLockMap 关系分组锁定统计。
* @param {Map<string, Object>} relationMap 签约关系记录映射。
* @param {Object} storeWarehouseModel 签约关系模型。
* @param {Object} transaction 数据库事务。
* @return {Promise<void>} 无返回值。
*/
async lockWaybillRelationBalance(relationLockMap, relationMap, storeWarehouseModel, transaction) {
if (!relationLockMap || relationLockMap.size === 0) {
return;
}
for (const relationLock of relationLockMap.values()) {
const relationKey = `${relationLock.store_id}:${relationLock.warehouse_id}`;
const relation = relationMap.get(relationKey);
if (!relation) {
continue;
}
const currentLockedQuantity = Number(relation.print_quantity_locked || 0);
const incrementQuantity = Number(relationLock.locked_quantity || 0);
if (incrementQuantity <= 0) {
continue;
}
await storeWarehouseModel.update({
print_quantity_locked: currentLockedQuantity + incrementQuantity,
}, {
where: {
id: relation.id,
},
transaction,
});
}
}
/**
* 将运单失败订单批量回写为异常状态。
*
* @param {Object} orderDeliveryModel 订单主表模型。
* @param {Array<number>} orderIds 订单ID 列表。
* @param {string} exceptionText 异常信息。
* @param {Object} transaction 数据库事务。
* @return {Promise<void>} 无返回值。
*/
async markWaybillOrdersAsException(orderDeliveryModel, orderIds = [], exceptionText = '', transaction) {
const { Op } = this.app.Sequelize;
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
.map(orderId => Number(orderId))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)));
if (normalizedOrderIds.length === 0 || !exceptionText) {
return;
}
await orderDeliveryModel.update({
inspection_status: 'error',
step: WAYBILL_EXCEPTION_STEP,
order_flag: exceptionText,
updated_at: new Date(),
}, {
where: {
id: {
[Op.in]: normalizedOrderIds,
},
},
transaction,
});
}
/**
* 批量回写运单创建失败订单的异常状态。
*【已使用】
* @param {Object} orderDeliveryModel 订单主表模型。
* @param {Map<string, Array<number>>} failedOrdersByReason 失败原因与订单 ID 映射。
* @param {Object} transaction 数据库事务。
* @return {Promise<void>} 无返回值。
*/
async writeWaybillOrderExceptions(orderDeliveryModel, failedOrdersByReason = new Map(), transaction) {
if (!failedOrdersByReason || typeof failedOrdersByReason.forEach !== 'function') {
return;
}
for (const [ exceptionText, orderIds ] of failedOrdersByReason.entries()) {
await this.markWaybillOrdersAsException(orderDeliveryModel, orderIds, exceptionText, transaction);
}
}
/**
* 将运单异步后处理失败订单批量回写为错误状态。
*
* @param {Object} orderDeliveryModel 订单主表模型。
* @param {Array<number>} orderIds 订单ID 列表。
* @param {string} errorMessage 错误信息。
* @return {Promise<void>} 无返回值。
*/
async markWaybillAsyncOrdersAsError(orderDeliveryModel, orderIds = [], errorMessage = '') {
if (!orderDeliveryModel || typeof orderDeliveryModel.update !== 'function') {
return;
}
const { Op } = this.app.Sequelize;
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
.map(orderId => Number(orderId))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)));
const normalizedErrorMessage = String(errorMessage || '').trim() || '接口调用失败';
if (normalizedOrderIds.length === 0) {
return;
}
await orderDeliveryModel.update({
post_status: 'error',
step: 3,
order_flag: normalizedErrorMessage,
updated_at: new Date(),
}, {
where: {
id: {
[Op.in]: normalizedOrderIds,
},
},
});
}
/**
* 生成合并后的快递项展示名称。
*
* @param {string} settingCode 快递设置编码
* @param {Object} expressItem 系统快递项
* @return {string} 展示名称
*/
buildMergedExpressLabel(settingCode, expressItem) {
const normalizedSettingCode = String(settingCode || '').trim();
const expressName = String(expressItem && (expressItem.name || expressItem.label || expressItem.code || expressItem.value) || '').trim();
if (!normalizedSettingCode) {
return expressName;
}
if (!expressName) {
return normalizedSettingCode;
}
return `${normalizedSettingCode} (${expressName})`;
}
/**
* 规范化快递设置记录。
*
* @param {Object} row 数据库记录
* @param {Map<string, Object>} expressMap 系统快递映射
* @return {Object|null} 规范化后的记录
*/
normalizeExpressSettingRow(row, expressMap) {
if (!row || typeof row !== 'object') {
return null;
}
const code = String(row.code || '').trim();
if (!code) {
return null;
}
const expressCode = String(row.express_code || '').trim();
const expressItem = expressMap instanceof Map ? expressMap.get(expressCode) : null;
const label = this.buildMergedExpressLabel(code, expressItem);
return {
code,
name: label,
value: code,
label,
is_system_setting: true,
id: row.id === undefined || row.id === null ? null : row.id,
alias: String(row.name || '').trim(),
express_code: String((expressItem && (expressItem.code || expressItem.value)) || expressCode || '').trim(),
};
}
/**
* 从数据库加载快递设置列表。
*
* @param {number|string} warehouseId 仓库ID
* @return {Promise<Array>} 快递设置列表
*/
async loadExpressSettingListFromDatabase(warehouseId = 0) {
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return [];
}
const expressSettingModel = this.ctx.model && this.ctx.model.ExpressSetting;
if (!expressSettingModel || typeof expressSettingModel.findAll !== 'function') {
return [];
}
const rows = await expressSettingModel.findAll({
attributes: [ 'id', 'code', 'name', 'express_code' ],
where: {
warehouse_id: normalizedWarehouseId,
},
order: [[ 'code', 'ASC' ]],
raw: true,
});
if (!Array.isArray(rows)) {
return [];
}
return rows;
}
/**
* 合并系统快递和快递设置列表。
*
* @param {Array<Object>} expressList 系统快递列表
* @param {Array<Object>} expressSettingList 快递设置列表
* @return {Array<Object>} 合并后的快递列表
*/
buildMergedExpressList(expressList, expressSettingList) {
const mergedList = [];
const seenCodeMap = new Set();
const normalizedExpressList = Array.isArray(expressList) ? expressList : [];
const expressMap = new Map();
for (const expressItem of normalizedExpressList) {
if (!expressItem || typeof expressItem !== 'object') {
continue;
}
const code = String(expressItem.code || expressItem.value || '').trim();
if (!code) {
continue;
}
if (!expressMap.has(code)) {
expressMap.set(code, expressItem);
}
}
for (const expressItem of normalizedExpressList) {
if (!expressItem || typeof expressItem !== 'object') {
continue;
}
const code = String(expressItem.code || expressItem.value || '').trim();
if (!code || seenCodeMap.has(code)) {
continue;
}
mergedList.push(expressItem);
seenCodeMap.add(code);
}
for (const row of Array.isArray(expressSettingList) ? expressSettingList : []) {
const mergedItem = this.normalizeExpressSettingRow(row, expressMap);
if (!mergedItem || seenCodeMap.has(mergedItem.code)) {
continue;
}
mergedList.push(mergedItem);
seenCodeMap.add(mergedItem.code);
}
return mergedList;
}
/**
* 生成快递产品类型列表缓存键。
*
* @param {string} expressCode 快递公司编码
* @return {string} 缓存键
*/
getExpressProductTypeListCacheKey(expressCode = '') {
const normalizedExpressCode = String(expressCode || '').trim();
if (!normalizedExpressCode) {
return 'express:product-type:list';
}
return `express:product-type:list:${normalizedExpressCode}`;
}
/**
* 规范化快递产品类型记录。
*
* @param {Object} row 数据库记录
* @return {Object|null} 规范化后的记录
*/
normalizeExpressProductTypeRow(row) {
if (!row || typeof row !== 'object') {
return null;
}
const code = String(row.code || '').trim();
if (!code) {
return null;
}
const name = String(row.name || '').trim();
return {
code,
express_code: String(row.express_code || '').trim(),
name,
value: code,
label: name || code,
};
}
normalizeExpressRow(row) {
if (!row || typeof row !== 'object') {
return null;
}
const code = String(row.code || '').trim();
if (!code) {
return null;
}
return {
code,
name: String(row.name || '').trim(),
value: code,
label: String(row.name || code).trim(),
is_system_setting: false,
id: null,
alias: null,
};
}
async loadExpressList() {
const cachedList = await this.loadExpressListFromCache();
if (cachedList !== null) {
return cachedList;
}
const expressList = await this.loadExpressListFromDatabase();
await this.app.setCacheAsync('express:list:system:normal', expressList, DEFAULT_CACHE_TTL_SECONDS);
return expressList;
}
async loadExpressListFromCache() {
const key = 'express:list:system:normal';
try {
const cachedList = await this.app.getCacheAsync(key);
if (cachedList !== null && cachedList !== undefined) {
return Array.isArray(cachedList) ? cachedList : [];
}
} catch (error) {
this.ctx.logger.warn('[ExpressService.loadExpressListFromCache] 获取系统快递列表缓存失败: %s', error.message);
}
return null;
}
async loadExpressListFromDatabase() {
const rows = await this.ctx.model.Express.findAll({
order: [[ 'code', 'ASC' ]],
raw: true,
});
if (!Array.isArray(rows)) {
return [];
}
return rows;
}
/**
* 获取系统快递编码和名称列表。
*
* 该接口只返回系统基础快递数据,不合并仓库自定义映射。
*
* @return {Promise<Array>} 系统快递编码和名称列表
*/
async getSystemExpressList() {
return await this.loadExpressListFromDatabase();
}
/**
* 从数据库加载快递产品类型列表。
*
* @param {string} expressCode 快递公司编码
* @return {Promise<Array>} 快递产品类型列表
*/
async loadExpressProductTypeListFromDatabase(expressCode = '') {
const normalizedExpressCode = String(expressCode || '').trim();
const query = {
attributes: [ 'code', 'name', 'express_code' ],
order: [[ 'express_code', 'ASC' ], [ 'code', 'ASC' ]],
raw: true,
};
if (normalizedExpressCode) {
query.where = {
express_code: normalizedExpressCode,
};
}
const rows = await this.ctx.model.ExpressProductType.findAll(query);
if (!Array.isArray(rows)) {
return [];
}
return rows
.map(row => this.normalizeExpressProductTypeRow(row))
.filter(Boolean);
}
/**
* 获取快递列表。
*
* 默认先读取系统快递,再按当前仓库合并快递设置;同一编码只保留一条记录。
* systemOnly 为 true 时仅返回系统快递列表。
*
* @param {boolean} [systemOnly=false] 是否仅返回系统基础快递列表
* @return {Promise<Array>} 快递列表
*/
async getExpressList(systemOnly = false) {
const warehouseId = this.getCurrentWarehouseId();
const cacheKey = this.getExpressListCacheKey(warehouseId, systemOnly);
try {
const cachedList = await this.app.getCacheAsync(cacheKey);
if (cachedList !== null && cachedList !== undefined) {
return Array.isArray(cachedList) ? cachedList : [];
}
if (systemOnly) {
const expressList = await this.getSystemExpressList();
await this.app.setCacheAsync(cacheKey, expressList, DEFAULT_CACHE_TTL_SECONDS);
return expressList;
}
const [ expressList, expressSettingList ] = await Promise.all([
this.loadExpressListFromDatabase(),
this.loadExpressSettingListFromDatabase(warehouseId),
]);
const mergedList = this.buildMergedExpressList(expressList, expressSettingList);
await this.app.setCacheAsync(cacheKey, mergedList, DEFAULT_CACHE_TTL_SECONDS);
return mergedList;
} catch (error) {
this.ctx.logger.error('[ExpressService.getExpressList] 获取快递列表失败', {
error: error.message,
stack: error.stack,
});
throw error;
}
}
/**
* 获取快递产品类型列表。
*
* @param {string} expressCode 快递公司编码
* @return {Promise<Array>} 快递产品类型列表
*/
async getExpressProductTypeList(expressCode = '') {
const cacheKey = this.getExpressProductTypeListCacheKey(expressCode);
const normalizedExpressCode = String(expressCode || '').trim();
try {
const cachedList = await this.app.getCacheAsync(cacheKey);
if (cachedList !== null && cachedList !== undefined) {
return Array.isArray(cachedList) ? cachedList : [];
}
const expressProductTypeList = await this.loadExpressProductTypeListFromDatabase(normalizedExpressCode);
await this.app.setCacheAsync(cacheKey, expressProductTypeList, DEFAULT_EXPRESS_PRODUCT_TYPE_CACHE_TTL_SECONDS);
return expressProductTypeList;
} catch (error) {
this.ctx.logger.error('[ExpressService.getExpressProductTypeList] 获取快递产品类型失败', {
error: error.message,
stack: error.stack,
expressCode: normalizedExpressCode,
});
throw error;
}
}
/**
* 按 sys_platform_code 和 logistics_code 对订单进行分组。
*【已使用】
* @param {Array<Object>} orders 已规范化的订单列表
* @return {Array<Object>} 分组结果
*/
groupWaybillOrdersByPlatformAndLogistics(orders = []) {
// 【step2】按平台 + 快递编码+货主id分组,后续按组串行处理。
const groupedOrders = [];
const groupedOrderMap = new Map();
for (const order of Array.isArray(orders) ? orders : []) {
if (!order || typeof order !== 'object') {
continue;
}
const sysPlatformCode = String(order.sys_platform_code || '').trim();
const logisticsCode = String(order.logistics_code || '').trim();
if (!sysPlatformCode || !logisticsCode) {
continue;
}
const groupKey = `${sysPlatformCode}:${logisticsCode}:${order.store_id || 0}`;
let groupedOrder = groupedOrderMap.get(groupKey);
if (!groupedOrder) {
groupedOrder = {
options: {
sys_platform_code: sysPlatformCode,
logistics_code: logisticsCode,
sys_platform_name: order.sys_platform_name || '',
logistics_name: order.logistics_name || '',
store_id: order.store_id || 0,
},
orders: [],
};
groupedOrderMap.set(groupKey, groupedOrder);
groupedOrders.push(groupedOrder);
}
groupedOrder.orders.push(order);
}
return groupedOrders;
}
/**
* 将订单按指定数量拆分为多个批次。
*【已使用】
* @param {Array<Object>} orders 订单列表
* @param {number} [batchSize=10] 每批最大数量
* @return {Array<Array<Object>>} 批次列表
*/
splitWaybillOrdersIntoBatches(orders = [], batchSize = DEFAULT_WAYBILL_BATCH_SIZE) {
// 【step3】按批大小切分订单,控制单次创建量。
const normalizedOrders = Array.isArray(orders) ? orders : [];
const normalizedBatchSize = Math.floor(Number(batchSize));
const effectiveBatchSize = Number.isFinite(normalizedBatchSize) && normalizedBatchSize > 0
? normalizedBatchSize
: DEFAULT_WAYBILL_BATCH_SIZE;
const batches = [];
for (let index = 0; index < normalizedOrders.length; index += effectiveBatchSize) {
batches.push(normalizedOrders.slice(index, index + effectiveBatchSize));
}
return batches;
}
/**
* 解析运单后处理可用的平台编码。
*
* @param {Object} order 订单或平台上下文。
// 【step4】检查余额、锁定可用数量,并拆出成功与失败订单。
* @return {string} 平台编码,小写。
*/
resolveWaybillAsyncPlatformCode(order = {}) {
if (!order || typeof order !== 'object') {
return '';
}
const expressPlatform = order.wms_express_platform && typeof order.wms_express_platform === 'object'
? order.wms_express_platform
: (order.wmsExpressPlatform && typeof order.wmsExpressPlatform === 'object' ? order.wmsExpressPlatform : null);
const rawPlatformCode = (expressPlatform && (expressPlatform.platform_code || expressPlatform.platformCode))
|| order.express_platform_code
|| order.expressPlatformCode
|| order.platform_code
|| order.platformCode
|| order.sys_platform_code
|| order.sysPlatformCode
|| (typeof order.wms_express_platform === 'string' ? order.wms_express_platform : '')
|| (typeof order.wmsExpressPlatform === 'string' ? order.wmsExpressPlatform : '');
return String(rawPlatformCode || '').trim().toLowerCase();
}
/**
* 按平台编码汇总需要异步后处理的订单。
*
* @param {Array<Object>} orders 成功订单列表。
// 【step5】把失败订单回写为异常状态,供主链路统一收口。
* @return {Array<Object>} 平台分组结果。
*/
groupWaybillAsyncOrdersByPlatform(orders = []) {
const groupedOrderMap = new Map();
for (const order of Array.isArray(orders) ? orders : []) {
if (!order || typeof order !== 'object') {
continue;
}
const platformCode = this.resolveWaybillAsyncPlatformCode(order);
let groupedOrder = groupedOrderMap.get(platformCode);
if (!groupedOrder) {
groupedOrder = {
platform_code: platformCode,
orders: [],
};
groupedOrderMap.set(platformCode, groupedOrder);
}
groupedOrder.orders.push(order);
}
return Array.from(groupedOrderMap.values());
}
/**
* 将订单主表快照按订单 ID 建立映射。
*【已使用】
* @param {Array<Object>} orderDeliveryRows 订单主表查询结果。
// 【step5】按失败原因分批回写异常,避免失败链路遗漏。
* @return {Map<number, Object>} 订单快照映射。
*/
buildWaybillOrderDeliveryMap(orderDeliveryRows = []) {
const orderDeliveryMap = new Map();
for (const row of Array.isArray(orderDeliveryRows) ? orderDeliveryRows : []) {
const orderId = Number(row && row.id);
if (Number.isFinite(orderId) && orderId > 0) {
orderDeliveryMap.set(orderId, row);
}
}
return orderDeliveryMap;
}
/**
* 将异步后处理文本字段标准化。
*
* @param {*} value 原始值。
* @return {string|null} 标准化结果。
*/
normalizeWaybillAsyncText(value) {
if (value === undefined || value === null) {
return null;
}
const normalizedValue = String(value).trim();
return normalizedValue ? normalizedValue : null;
}
/**
* 将异步后处理数值字段标准化。
*
* @param {*} value 原始值。
* @return {number} 标准化结果。
*/
normalizeWaybillAsyncNumber(value) {
const normalizedValue = Number(value);
return Number.isFinite(normalizedValue) ? normalizedValue : 0;
}
/**
* 将异步后处理日期字段标准化为 ISO 字符串。
*
* @param {*} value 原始值。
* @return {string|null} 标准化结果。
*/
formatWaybillAsyncDate(value) {
if (value === undefined || value === null || value === '') {
return null;
}
const date = value instanceof Date ? value : new Date(value);
if (Number.isNaN(date.getTime())) {
return null;
}
return date.toISOString();
}
/**
* 标准化异步后处理商品明细字段。
*
* @param {*} value 原始值。
* @return {Array} 标准化结果。
*/
normalizeWaybillAsyncItems(value) {
if (Array.isArray(value)) {
return value.map(item => (typeof item === 'string' ? item.trim() : item));
}
if (typeof value === 'string') {
return value
.split('|')
.map(item => item.trim())
.filter(Boolean);
}
return [];
}
/**
* 构建异步后处理中的路由信息块。
*
* @param {Object} order 订单上下文。
* @param {Object} orderDelivery 订单主表快照。
* @return {Object} 路由信息块。
*/
buildWaybillAsyncRouteInfo(order = {}, orderDelivery = {}) {
return {
source_platform_code: this.normalizeWaybillAsyncText(orderDelivery.source_platform_code),
source_platform_name: this.normalizeWaybillAsyncText(orderDelivery.source_platform_name),
sys_platform_code: this.normalizeWaybillAsyncText(orderDelivery.sys_platform_code || order.sys_platform_code),
sys_platform_name: this.normalizeWaybillAsyncText(orderDelivery.sys_platform_name),
logistics_code: this.normalizeWaybillAsyncText(order.logistics_code || orderDelivery.logistics_code),
logistics_name: this.normalizeWaybillAsyncText(orderDelivery.logistics_name),
sys_logistics_code: this.normalizeWaybillAsyncText(orderDelivery.sys_logistics_code),
sys_logistics_name: this.normalizeWaybillAsyncText(orderDelivery.sys_logistics_name),
express_code: this.normalizeWaybillAsyncText(orderDelivery.express_code),
logistics_area_code: this.normalizeWaybillAsyncText(orderDelivery.logistics_area_code),
};
}
/**
* 构建异步后处理中的订单信息块。
*
* @param {Object} orderDelivery 订单主表快照。
* @return {Object} 订单信息块。
*/
buildWaybillAsyncOrderInfo(orderDelivery = {}) {
return {
delivery_order_code: this.normalizeWaybillAsyncText(orderDelivery.delivery_order_code),
order_type: this.normalizeWaybillAsyncText(orderDelivery.order_type),
status: this.normalizeWaybillAsyncText(orderDelivery.status),
step: this.normalizeWaybillAsyncNumber(orderDelivery.step),
order_flag: this.normalizeWaybillAsyncText(orderDelivery.order_flag),
from_key: this.normalizeWaybillAsyncText(orderDelivery.from_key),
create_at: this.formatWaybillAsyncDate(orderDelivery.create_at),
place_order_time: this.formatWaybillAsyncDate(orderDelivery.place_order_time),
pay_time: this.formatWaybillAsyncDate(orderDelivery.pay_time),
operate_time: this.formatWaybillAsyncDate(orderDelivery.operate_time),
delivery_time: this.formatWaybillAsyncDate(orderDelivery.delivery_time),
};
}
/**
* 构建异步后处理中的收件人信息块。
*
* @param {Object} orderDelivery 订单主表快照。
* @return {Object} 收件人信息块。
*/
buildWaybillAsyncReceiverInfo(orderDelivery = {}) {
return {
name: this.normalizeWaybillAsyncText(orderDelivery.name),
tel: this.normalizeWaybillAsyncText(orderDelivery.tel),
mobile: this.normalizeWaybillAsyncText(orderDelivery.mobile),
email: this.normalizeWaybillAsyncText(orderDelivery.email),
country_code: this.normalizeWaybillAsyncText(orderDelivery.country_code),
province: this.normalizeWaybillAsyncText(orderDelivery.province),
city: this.normalizeWaybillAsyncText(orderDelivery.city),
area: this.normalizeWaybillAsyncText(orderDelivery.area),
town: this.normalizeWaybillAsyncText(orderDelivery.town),
detail_address: this.normalizeWaybillAsyncText(orderDelivery.detail_address),
zip_code: this.normalizeWaybillAsyncText(orderDelivery.zip_code),
};
}
/**
* 构建异步后处理中的结算信息块。
*
* @param {Object} orderDelivery 订单主表快照。
* @return {Object} 结算信息块。
*/
buildWaybillAsyncSettlementInfo(orderDelivery = {}) {
return {
total_amount: this.normalizeWaybillAsyncNumber(orderDelivery.total_amount),
item_amount: this.normalizeWaybillAsyncNumber(orderDelivery.item_amount),
discount_amount: this.normalizeWaybillAsyncNumber(orderDelivery.discount_amount),
freight: this.normalizeWaybillAsyncNumber(orderDelivery.freight),
ar_amount: this.normalizeWaybillAsyncNumber(orderDelivery.ar_amount),
got_amount: this.normalizeWaybillAsyncNumber(orderDelivery.got_amount),
};
}
/**
* 构建异步后处理中的商品汇总信息块。
*
* @param {Object} orderDelivery 订单主表快照。
* @return {Object} 商品汇总信息块。
*/
buildWaybillAsyncItemsSummary(orderDelivery = {}) {
return {
items: this.normalizeWaybillAsyncItems(orderDelivery.items),
items_count: this.normalizeWaybillAsyncNumber(orderDelivery.items_count),
items_total: this.normalizeWaybillAsyncNumber(orderDelivery.items_total),
items_weight: this.normalizeWaybillAsyncNumber(orderDelivery.items_weight),
};
}
/**
* 构建异步后处理中的单个订单项。
*
* @param {Object} order 成功订单上下文。
* @return {Object} 订单项快照。
*/
buildWaybillAsyncOrderListItem(order = {}) {
const orderDelivery = order && typeof order.order_delivery === 'object' ? order.order_delivery : {};
return {
order_id: this.normalizeWaybillAsyncNumber(order.order_id),
business_key: this.normalizeWaybillAsyncNumber(order.business_key),
sys_platform_code: this.normalizeWaybillAsyncText(order.sys_platform_code || orderDelivery.sys_platform_code),
logistics_code: this.normalizeWaybillAsyncText(order.logistics_code || orderDelivery.logistics_code),
express_platform_code: this.normalizeWaybillAsyncText(order.express_platform_code || orderDelivery.express_platform_code || this.resolveWaybillAsyncPlatformCode(order)),
route_info: this.buildWaybillAsyncRouteInfo(order, orderDelivery),
order_info: this.buildWaybillAsyncOrderInfo(orderDelivery),
receiver_info: this.buildWaybillAsyncReceiverInfo(orderDelivery),
settlement_info: this.buildWaybillAsyncSettlementInfo(orderDelivery),
items_summary: this.buildWaybillAsyncItemsSummary(orderDelivery),
};
}
/**
* 运单后处理 bizcontent 骨架的返回结构。
*
* 顶层返回对象仅包含一个 `bizcontent` 字段,方便后续按平台继续扩展。
*
* @typedef {Object} WaybillAsyncBizcontentSkeletonResult
* @property {WaybillAsyncBizcontentSkeleton} bizcontent 顶层业务载荷对象。
*/
/**
* 运单后处理 bizcontent 的完整结构。
*
* 该结构当前只负责承载统一字段与订单列表骨架,平台差异字段按需挂载。
*
* @typedef {Object} WaybillAsyncBizcontentSkeleton
* @property {string} platform_code 平台编码,来源于当前业务上下文或订单分组结果。
* @property {string} [express_platform_code] 物流平台编码,仅在上游传入时保留。
* @property {number} store_id 店铺 ID,未传时为 `0`。
* @property {number} warehouse_id 仓库 ID,未传时为 `0`。
* @property {Array<WaybillAsyncOrderItemSkeleton>} order_list 订单列表骨架。
* @property {Object} platform_payload 平台专属载荷占位对象,当前固定为空对象。
*/
/**
* `order_list` 中单个订单项的结构。
*
* @typedef {Object} WaybillAsyncOrderItemSkeleton
* @property {number} order_id 订单 ID,未能解析时为 `0`。
* @property {number} business_key 业务主键,未能解析时为 `0`。
* @property {string} sys_platform_code 系统平台编码,做了去空格处理。
* @property {string} logistics_code 物流编码,做了去空格处理。
* @property {string} express_platform_code 当前订单对应的物流平台编码。
*/
/**
* 构建运单后处理统一业务数据骨架。
*
* 仅保留请求级公共字段与订单列表骨架,平台差异字段暂时留空,后续再补充。
*
* 返回数据结构如下:
* - 顶层返回对象:`{ bizcontent: WaybillAsyncBizcontentSkeleton }`
* - `bizcontent`:包含平台编码、店铺 ID、仓库 ID、订单列表和平台专属载荷占位
* - `order_list`:由多个 `WaybillAsyncOrderItemSkeleton` 组成
* - `platform_payload`:当前固定为空对象 `{}`,用于后续按平台补充差异字段
*
* @param {Array<Object>} orders 成功订单列表。
* @param {Object} [options={}] 业务上下文。
* @return {WaybillAsyncBizcontentSkeletonResult} 统一业务数据骨架。
*/
buildWaybillAsyncBizcontentSkeleton(orders = [], options = {}) {
const normalizedOrders = Array.isArray(orders) ? orders : [];
const platformCode = this.resolveWaybillAsyncPlatformCode({
...options,
wms_express_platform: options.wms_express_platform || options.wmsExpressPlatform || null,
});
const expressPlatformCode = String(options.express_platform_code || options.expressPlatformCode || '').trim();
return {
bizcontent: {
platform_code: platformCode,
store_id: Number(options.store_id || options.storeId || 0) || 0,
warehouse_id: Number(options.warehouse_id || options.warehouseId || 0) || 0,
order_list: normalizedOrders.map(order => this.buildWaybillAsyncOrderListItem(order)),
platform_payload: {},
...(expressPlatformCode ? { express_platform_code: expressPlatformCode } : {}),
// 这里先不拼平台公共字段,后续再补充平台凭证、接口版本、渠道参数等内容。
},
};
}
/**
* 将统一业务数据骨架按平台编码分流。
*
* 直接调用平台服务实例上的同名方法;如果方法不存在,或平台方法返回失败结果,则向上抛出异常。
*
* @param {string} platformCode 平台编码。
* @param {Object} bizcontent 统一业务数据骨架。
*/
async dispatchWaybillAsyncPlatform(platformCode = '', bizcontent = {}) {
const normalizedPlatformCode = String(platformCode).trim().toLowerCase();
const expressPlatformService = this.service
&& this.service.systems
&& (this.service.systems.expressPlatform || this.service.systems.express_platform);
const dispatchMethod = expressPlatformService && expressPlatformService[normalizedPlatformCode];
if (typeof dispatchMethod !== 'function') {
throw new Error(normalizedPlatformCode + '接口未实现');
}
const dispatchResult = await dispatchMethod.call(expressPlatformService, bizcontent);
if (dispatchResult && typeof dispatchResult === 'object' && dispatchResult.flag === 'failure') {
throw new Error(dispatchResult.message || normalizedPlatformCode + '接口调用失败');
}
}
/**
* 硬删除运单异步失败分组对应的订单快递记录。
*
* 删除条件必须同时包含订单ID和业务键,若任一订单缺少 business_key,则记录原因并跳过整个分组,避免误删。
*
* @param {Array<Object>} orders 失败分组订单列表。
* @param {Object} [options={}] 分组上下文。
* @param {string} [options.platform_code=''] 平台编码。
* @param {string} [options.error_message=''] 失败原因。
* @return {Promise<boolean>} 是否已成功执行硬删除。
*/
async hardDeleteWaybillAsyncOrderExpressRows(orders = [], options = {}) {
const { Op } = this.app.Sequelize;
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
if (!orderExpressModel || typeof orderExpressModel.destroy !== 'function') {
this.ctx.logger.error('[ExpressService.hardDeleteWaybillAsyncOrderExpressRows] 订单快递模型未初始化,跳过失败分组硬删', {
platform_code: String(options.platform_code || '').trim(),
error_message: String(options.error_message || '').trim(),
});
return false;
}
const normalizedOrders = Array.isArray(orders) ? orders : [];
const deleteConditions = [];
for (const order of normalizedOrders) {
const orderId = Number(order && order.order_id);
const businessKey = Number(order && order.business_key);
if (!Number.isFinite(orderId) || orderId <= 0) {
this.ctx.logger.error('[ExpressService.hardDeleteWaybillAsyncOrderExpressRows] 失败分组订单缺少有效 order_id,已跳过该分组硬删', {
order_id: order && order.order_id,
business_key: order && order.business_key,
platform_code: String(options.platform_code || '').trim(),
error_message: String(options.error_message || '').trim(),
});
return false;
}
if (!Number.isFinite(businessKey) || businessKey <= 0) {
this.ctx.logger.error('[ExpressService.hardDeleteWaybillAsyncOrderExpressRows] 失败分组订单缺少 business_key,已跳过该分组硬删与回写', {
order_id: orderId,
business_key: order && order.business_key,
platform_code: String(options.platform_code || '').trim(),
error_message: String(options.error_message || '').trim(),
});
return false;
}
deleteConditions.push({
order_id: orderId,
business_key: businessKey,
});
}
if (deleteConditions.length === 0) {
return false;
}
try {
await orderExpressModel.destroy({
where: {
[Op.or]: deleteConditions,
},
});
return true;
} catch (error) {
this.ctx.logger.error('[ExpressService.hardDeleteWaybillAsyncOrderExpressRows] 失败分组硬删订单快递记录失败', {
error: error.message,
stack: error.stack,
platform_code: String(options.platform_code || '').trim(),
error_message: String(options.error_message || '').trim(),
delete_conditions: deleteConditions,
});
return false;
}
}
/**
* 获取运单异步后处理使用的订单主表模型。
*
* 优先使用当前上下文中已挂载的订单主表模型;如果只有工厂,则按仓库 ID 取当前模型。
*
* @param {number} currentWarehouseId 当前仓库 ID。
* @return {Promise<Object|null>} 订单主表模型或空值。
* 【已使用】
*/
async getWaybillAsyncOrderDeliveryModel(currentWarehouseId = 0) {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!currentWarehouseId || !orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
return null;
}
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(currentWarehouseId);
if (!orderDeliveryModel || typeof orderDeliveryModel.update !== 'function') {
return null;
}
return orderDeliveryModel;
}
/**
* 按分组和批次顺序初始化订单运单表。
*
* 先标准化订单,再按 sys_platform_code 和 logistics_code 分组,
* 最后按每批最多 10 条的规则顺序调用现有 createWaybillCode。
* business_key 支持单值或数组输入,内部会展开成多条记录后再分组批处理。
*【已使用】
* @param {Array<Object>} orders 订单与业务键列表。
* @return {Promise<Object>} 处理结果,包含 orders、waybill_codes 和 skippedOrders。
*/
async createWaybillCodePipeline(orders = []) {
const { app } = this;
const { Op } = app.Sequelize;
const orderList = Array.isArray(orders) ? orders : [];
const traceId = this.buildWaybillTraceId({}, `pipeline_${Date.now()}`);
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 入口请求', {
traceId,
orderCount: orderList.length,
orderIds: orderList.slice(0, 50).map(order => Number(order && order.order_id)).filter(orderId => Number.isFinite(orderId) && orderId > 0),
waveIds: orderList.slice(0, 50).map(order => Number(order && order.wave_id)).filter(waveId => Number.isFinite(waveId) && waveId > 0),
});
const warehouseId = this.getCurrentWarehouseId();
const orderDeliveryModel = await this.getWaybillAsyncOrderDeliveryModel(warehouseId);
if (!orderDeliveryModel || typeof orderDeliveryModel.findAll !== 'function') {
this.ctx.logger.error('[ExpressService.createWaybillCodePipeline] 分配前置条件失败-订单主表模型不可用', {
traceId,
warehouseId,
});
throw new Error('订单主表模型未初始化');
}
// 【step1】先按订单ID和业务键筛选 wms_order_express,找出已存在的快递记录,避免重复创建。
const orders_arr = await orderDeliveryModel.findAll({
where: {
id: orderList.map(order => Number(order && order.order_id)).filter(orderId => Number.isFinite(orderId) && orderId > 0),
warehouse_id: warehouseId,
step: {
[Op.in]: [ 1, 2, 3 ],
},
},
attributes: [ 'id', 'sys_platform_code', 'logistics_code', 'sys_platform_name', 'logistics_name', 'store_id' ],
raw: true,
});
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 订单筛选结果', {
traceId,
warehouseId,
inputOrderCount: orderList.length,
matchedOrderCount: Array.isArray(orders_arr) ? orders_arr.length : 0,
});
// orders_arr和orderList合并
const ordersWithExpress = orders_arr.map(order => {
const matchedExpress = orderList.find(express => Number(order.id) === Number(express.order_id));
return {
...order,
business_key: matchedExpress ? matchedExpress.business_key : 1,
};
});
const groupedOrders = this.groupWaybillOrdersByPlatformAndLogistics(ordersWithExpress);
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 平台物流分组结果', {
traceId,
groupedCount: groupedOrders.length,
});
// 【step2】按平台 + 快递编码分组,后续按组串行处理。
const platformList = await this.service.systems.platform.getPlatformList(true, true);
for (const groupedOrder of groupedOrders) {
const matchedPlatform = platformList.find(platform => String(platform.code || '').trim().toLowerCase() === String(groupedOrder.options.sys_platform_code || '').trim().toLowerCase());
const batches = this.splitWaybillOrdersIntoBatches(groupedOrder.orders);
const listByWarehousePlatformCode = await this.service.systems.setting.expressInterface.listByWarehousePlatformCode({ warehouseId, platform_code: groupedOrder.options.sys_platform_code });
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 分组前置条件检查', {
traceId,
warehouseId,
storeId: groupedOrder.options.store_id || 0,
sysPlatformCode: groupedOrder.options.sys_platform_code,
logisticsCode: groupedOrder.options.logistics_code,
matchedPlatformCode: matchedPlatform && matchedPlatform.code,
hasExpressInterface: Boolean(listByWarehousePlatformCode && listByWarehousePlatformCode.data && listByWarehousePlatformCode.data[0]),
});
// 先获取货主配置货主是否配置了发件人,如果没有再使用快递接口的发件人信息。发件人信息在 listByWarehousePlatformCode.data[0] 中。
const storeInfo = await this.service.systems.storeWarehouse.getContractConfig(warehouseId, groupedOrder.options.store_id);
const expressInterface = listByWarehousePlatformCode.data[0];
const storeConfig = storeInfo ? storeInfo.policy_config : null;
const useStoreSenderInfoValue = storeConfig ? storeConfig.use_store_sender_info : 1;
const shouldUseStoreSenderInfo = Number(useStoreSenderInfoValue === undefined || useStoreSenderInfoValue === null || useStoreSenderInfoValue === '' ? 1 : useStoreSenderInfoValue) === 1;
const expressInterfaceConfig = expressInterface ? {
...expressInterface,
...(shouldUseStoreSenderInfo ? {
shop_name: (storeConfig && storeConfig.shop_name) || expressInterface.shop_name || '',
sender_name: (storeConfig && storeConfig.sender_name) || expressInterface.sender_name || '',
sender_tel: (storeConfig && storeConfig.sender_tel) || expressInterface.sender_tel || '',
province_name: (storeConfig && storeConfig.province_name) || expressInterface.province_name || '',
city_name: (storeConfig && storeConfig.city_name) || expressInterface.city_name || '',
district_name: (storeConfig && storeConfig.district_name) || expressInterface.district_name || '',
town_name: (storeConfig && storeConfig.town_name) || expressInterface.town_name || '',
address: (storeConfig && storeConfig.address) || expressInterface.address || '',
} : {}),
} : null;
for (const batch of batches) {
// 异步不阻塞调用 createWaybillCode,快速返回结果给前端,后续的订单处理和异常回写都在 createWaybillCode 内部完成。
this.asyncTask(batch, {
...groupedOrder.options,
trace_id: traceId,
warehouse_id: warehouseId,
}, matchedPlatform, expressInterfaceConfig);
}
}
this.ctx.logger.info('[ExpressService.createWaybillCodePipeline] 流水线任务提交完成', {
traceId,
groupedCount: groupedOrders.length,
});
return { message: '分配快递任务已提交' };
}
/**
* 异步执行订单快递分配任务。错误订单转异常,并记录失败订单列表。
* 【已使用】
* @param {*} batch
* @param {*} sysPlatformCode
* @param {*} logisticsCode
* @param {*} matchedPlatform
* @param {*} listByWarehousePlatformCode
*/
async asyncTask(batch, options, matchedPlatform, listByWarehousePlatformCode) {
const traceId = this.buildWaybillTraceId(options || {}, 'asyncTask');
this.ctx.logger.info('[ExpressService.asyncTask] 任务入口', {
traceId,
warehouseId: options && options.warehouse_id,
sysPlatformCode: options && options.sys_platform_code,
logisticsCode: options && options.logistics_code,
orderIds: (Array.isArray(batch) ? batch : []).map(order => Number(order && (order.id || order.order_id))).filter(orderId => Number.isFinite(orderId) && orderId > 0),
waveIds: (Array.isArray(batch) ? batch : []).map(order => Number(order && order.wave_id)).filter(waveId => Number.isFinite(waveId) && waveId > 0),
});
try {
if (!listByWarehousePlatformCode) {
this.ctx.logger.warn('[ExpressService.asyncTask] 分配前置条件失败-快递接口配置缺失', {
traceId,
sysPlatformCode: options && options.sys_platform_code,
logisticsCode: options && options.logistics_code,
});
throw new Error(`当前订单平台【${options.sys_platform_name}】,快递【${options.logistics_name}】,未配置有效的快递接口`);
}
if (!matchedPlatform) {
this.ctx.logger.warn('[ExpressService.asyncTask] 分配前置条件失败-平台配置缺失', {
traceId,
sysPlatformCode: options && options.sys_platform_code,
logisticsCode: options && options.logistics_code,
});
throw new Error(`未找到订单平台【${options.sys_platform_name}】的有效平台配置`);
}
this.ctx.logger.info('[ExpressService.asyncTask] 调用 createWaybillCode 前', {
traceId,
batchCount: Array.isArray(batch) ? batch.length : 0,
});
await this.createWaybillCode(batch, matchedPlatform, {
...(listByWarehousePlatformCode || {}),
trace_id: traceId,
});
this.ctx.logger.info('[ExpressService.asyncTask] 调用 createWaybillCode 后', {
traceId,
batchCount: Array.isArray(batch) ? batch.length : 0,
});
} catch (error) {
console.error('异步任务执行失败:', error.message);
this.ctx.logger.error('[ExpressService.asyncTask] 异步任务执行异常', {
traceId,
error: error && error.message ? error.message : `${error}`,
stack: error && error.stack ? error.stack : '',
});
const err_orders = batch.map(order => ({
order_id: order && (order.id || order.order_id),
business_key: order.business_key,
}));
const failedOrderIds = err_orders
.map(order => Number(order && order.order_id))
.filter(orderId => Number.isFinite(orderId) && orderId > 0);
const logWarehouseId = this.getOrderLogWarehouseId(options && options.warehouse_id);
const errorMessage = error && error.message ? String(error.message) : String(error);
this.service.systems.orderPendingException.markPendingException(
{
ids: err_orders.map(order => order.order_id),
exception_text: `订单快递分配失败: ${errorMessage}`,
}
);
await this.createAllocateExpressFailureLogs(failedOrderIds, errorMessage, logWarehouseId);
await this.hardDeleteWaybillAsyncOrderExpressRows(err_orders, {
platform_code: options.sys_platform_code,
error_message: errorMessage,
});
}
}
/**
* 处理订单快递记录。
* 先按订单ID和业务键筛选 wms_order_express,再排除已存在且状态不为 0 的记录,
* 对可重试记录重置 retry_count,并为缺失记录补插状态为 0 的快递记录。
*【已使用】
* @param {Array<Object>} orders 订单与业务键列表,business_key 可为单值或数组。
* @param {number} orders[].order_id 订单ID。
* @param {number|Array<number>} orders[].business_key 业务键。
* @return {Promise<Object>} 处理后的订单列表与运单号列表。
*/
/**
* 创建运单编码并在事务后触发异步后处理。
*
* 事务成功后,如果异步后处理失败,则回补本次事务中已经增加的
* `print_quantity_locked`,避免锁定量长期偏高。
*
* @param {Array<Object>} orders 运单创建入参。
* @param {Object} [matchedPlatform={}] 平台匹配结果。
* @param {Object} [listByWarehousePlatformCode={}] 按仓库和平台分组的接口信息。
* @return {Promise<Object>} 创建结果。
*/
async createWaybillCode(orders, matchedPlatform, listByWarehousePlatformCode) {
const traceId = this.buildWaybillTraceId({
trace_id: listByWarehousePlatformCode && listByWarehousePlatformCode.trace_id,
traceId: listByWarehousePlatformCode && listByWarehousePlatformCode.traceId,
}, 'createWaybillCode');
this.ctx.logger.info('[ExpressService.createWaybillCode] 入口请求', {
traceId,
orderCount: Array.isArray(orders) ? orders.length : 0,
orderIds: (Array.isArray(orders) ? orders : []).slice(0, 50).map(order => Number(order && (order.id || order.order_id))).filter(orderId => Number.isFinite(orderId) && orderId > 0),
platformCode: matchedPlatform && matchedPlatform.code,
defaultExpressInterface: matchedPlatform && matchedPlatform.default_express_interface,
warehouseId: listByWarehousePlatformCode && listByWarehousePlatformCode.warehouse_id,
});
const { app, ctx } = this;
const { Op } = app.Sequelize;
const orderExpressModel = ctx.model && ctx.model.OrderExpress;
const currentWarehouseId = this.getCurrentWarehouseId();
if (!orderExpressModel
|| typeof orderExpressModel.findAll !== 'function'
|| typeof orderExpressModel.update !== 'function'
|| typeof orderExpressModel.bulkCreate !== 'function') {
throw new Error('订单快递模型未初始化');
}
const normalizedOrders = await this.normalizeWaybillCreateOrders(orders);
if (normalizedOrders.length === 0) {
return {
orders: [],
waybill_codes: [],
};
}
const orderDeliveryFactory = ctx.model && ctx.model.OrderDeliveryFactory;
const storeWarehouseModel = ctx.model && ctx.model.StoreWarehouse;
if (!currentWarehouseId) {
throw new Error('当前仓库ID不能为空');
}
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
throw new Error('订单主表模型未初始化');
}
if (!storeWarehouseModel || typeof storeWarehouseModel.findAll !== 'function' || typeof storeWarehouseModel.update !== 'function') {
throw new Error('签约关系模型未初始化');
}
const maxAttempts = 3;
/**
* 执行运单创建事务,并在死锁或锁等待超时时按次数重试。
* @param {number} attempt 当前尝试次数。
* @return {Promise<Object>} 运单创建事务结果。
*/
const executeCreateWaybillTransactionWithRetry = async attempt => {
try {
// 【step6】开启事务,确保余额锁定、异常回写和快递记录写入保持原子性。
return await app.model.transaction(async transaction => {
// 【step6】事务内先加载订单主表快照,后续所有判断都基于同一批视图。
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(currentWarehouseId);
const orderItemsFactory = ctx.model && ctx.model.OrderItemsFactory;
const orderItemsModel = orderItemsFactory && typeof orderItemsFactory.getCurrentModel === 'function'
? await orderItemsFactory.getCurrentModel(currentWarehouseId)
: null;
if (!orderDeliveryModel
|| typeof orderDeliveryModel.findAll !== 'function'
|| typeof orderDeliveryModel.update !== 'function') {
throw new Error('订单主表模型未初始化');
}
const orderDeliveryInclude = [];
if (orderItemsModel) {
orderDeliveryInclude.push({
model: orderItemsModel,
as: 'orderItems',
attributes: [ 'id', 'order_id', 'item_code', 'item_name', 'plan_qty', 'source_order_code' ],
required: false,
});
}
const orderDeliveryRows = await orderDeliveryModel.findAll({
// 保留后处理 order_list 需要的最小字段集,同时控制在 15 个字段以内。
// warehouse_id 由当前仓库 ID 兜底,因此不额外查询。
attributes: WAYBILL_ORDER_DELIVERY_MIN_ATTRIBUTES,
where: {
id: {
[Op.in]: normalizedOrders.map(order => order.order_id),
},
},
include: orderDeliveryInclude,
transaction,
});
const orderDeliveryMap = this.buildWaybillOrderDeliveryMap(orderDeliveryRows);
const existingCompletedRows = await orderExpressModel.findAll({
where: {
warehouse_id: currentWarehouseId,
[Op.or]: normalizedOrders.map(order => ({
order_id: order.order_id,
business_key: order.business_key,
})),
},
attributes: [ 'order_id', 'business_key', 'status' ],
raw: true,
transaction,
});
const completedOrderKeySet = new Set();
for (const row of Array.isArray(existingCompletedRows) ? existingCompletedRows : []) {
const orderId = Number(row && row.order_id);
const businessKey = Number(row && row.business_key);
const status = Number(row && row.status);
if (Number.isFinite(orderId) && orderId > 0 && Number.isInteger(businessKey) && status === 1) {
completedOrderKeySet.add(`${orderId}:${businessKey}`);
}
}
const pendingOrders = normalizedOrders.filter(order => !completedOrderKeySet.has(`${order.order_id}:${order.business_key}`));
if (pendingOrders.length === 0) {
return {
orders: [],
waybill_codes: [],
};
}
const {
relationGroupMap,
missingOrderIds,
} = this.buildWaybillCreateRelationGroups(pendingOrders, orderDeliveryRows, currentWarehouseId);
const relationWhereList = Array.from(relationGroupMap.values()).map(group => ({
store_id: group.store_id,
warehouse_id: group.warehouse_id,
}));
const relationRows = relationWhereList.length > 0
? await storeWarehouseModel.findAll({
attributes: [ 'id', 'store_id', 'warehouse_id', 'print_quantity', 'print_quantity_locked', 'policy_config' ],
where: {
[Op.or]: relationWhereList,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
})
: [];
const relationMap = new Map();
for (const relation of Array.isArray(relationRows) ? relationRows : []) {
const relationKey = `${Number(relation.store_id || 0)}:${Number(relation.warehouse_id || 0)}`;
if (relationKey !== '0:0') {
relationMap.set(relationKey, relation);
}
}
const {
successOrderKeySet,
failedOrdersByReason,
balanceWarnings,
} = await this.collectWaybillRelationProcessingState(relationGroupMap, relationMap);
if (missingOrderIds.length > 0) {
const exceptionText = '订单不存在或不属于当前仓库';
failedOrdersByReason.set(exceptionText, (failedOrdersByReason.get(exceptionText) || []).concat(missingOrderIds));
}
// 【step5】事务内统一回写失败订单异常,避免成功与失败状态分离。
await this.writeWaybillOrderExceptions(orderDeliveryModel, failedOrdersByReason, transaction);
if (balanceWarnings.length > 0) {
ctx.logger.warn('[ExpressService.createWaybillCode] 余额不足但允许超额分配: %s', balanceWarnings.join(';'));
}
const successOrders = pendingOrders.filter(order => successOrderKeySet.has(`${order.order_id}:${order.business_key}`));
const existingRows = await orderExpressModel.findAll({
where: {
[Op.or]: successOrders.map(order => ({
order_id: order.order_id,
business_key: order.business_key,
warehouse_id: currentWarehouseId,
})),
},
attributes: [ 'id', 'order_id', 'business_key', 'status', 'retry_count', 'warehouse_id' ],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const existingMap = new Map();
const retryIds = [];
for (const row of Array.isArray(existingRows) ? existingRows : []) {
const orderId = Number(row && row.order_id);
const businessKey = Number(row && row.business_key);
if (!Number.isFinite(orderId) || orderId <= 0 || !Number.isInteger(businessKey)) {
continue;
}
const orderKey = `${orderId}:${businessKey}`;
existingMap.set(orderKey, row);
// 过滤 status != 0 的已存在记录。
if (Number(row && row.status) === 0) {
retryIds.push(row.id);
}
}
// 【step6】先重置可重试记录,再补插缺失记录。
const retryableIds = Array.from(new Set(retryIds.filter(id => Number.isFinite(Number(id)) && Number(id) > 0)));
if (retryableIds.length > 0) {
await orderExpressModel.update({
retry_count: 0,
}, {
where: {
id: {
[Op.in]: retryableIds,
},
},
transaction,
});
}
const successOrdersWithDelivery = successOrders
.filter(order => {
const existingRow = existingMap.get(`${order.order_id}:${order.business_key}`);
return !existingRow || Number(existingRow.status) === 0;
})
.map(order => ({
...order,
order_delivery: orderDeliveryMap.get(order.order_id) || null,
}));
if (successOrdersWithDelivery.length > 0) {
const successOrderIds = Array.from(new Set(successOrdersWithDelivery
.map(order => Number(order.order_id))
.filter(orderId => Number.isFinite(orderId) && orderId > 0)));
if (successOrderIds.length > 0) {
await orderDeliveryModel.update({
step: 2,
updated_at: new Date(),
}, {
where: {
id: {
[Op.in]: successOrderIds,
},
},
transaction,
});
}
}
if (successOrdersWithDelivery.length === 0) {
return {
orders: [],
waybill_codes: [],
};
}
// 【step6】组装待插入记录,保持已存在且非 0 状态的记录不被覆盖。
const rowsToCreate = [];
for (const order of successOrders) {
const orderKey = `${order.order_id}:${order.business_key}`;
const existingRow = existingMap.get(orderKey);
if (existingRow) {
const status = Number(existingRow.status);
if (status !== 0) {
continue;
}
continue;
}
rowsToCreate.push({
order_id: order.order_id,
business_key: order.business_key,
status: 0,
retry_count: 0,
warehouse_id: this.getCurrentWarehouseId(),
});
}
const relationLockMap = this.buildWaybillRelationLockMap(successOrders, orderDeliveryMap, existingMap);
if (relationLockMap.size > 0) {
await this.lockWaybillRelationBalance(relationLockMap, relationMap, storeWarehouseModel, transaction);
}
// 【step6】批量插入新快递记录后,事务提交。
if (rowsToCreate.length > 0) {
await orderExpressModel.bulkCreate(rowsToCreate, {
transaction,
});
}
return {
orders: successOrdersWithDelivery,
waybill_codes: [],
};
});
} catch (err) {
const errorCode = err && err.parent && err.parent.code;
const errorMessage = String((err && err.message) || (err && err.parent && err.parent.message) || '');
const isRetryableDeadlock = errorCode === 'ER_LOCK_DEADLOCK'
|| errorCode === 'ER_LOCK_WAIT_TIMEOUT'
|| errorMessage.includes('Deadlock found when trying to get lock');
if (!isRetryableDeadlock || attempt >= maxAttempts) {
throw err;
}
ctx.logger.warn(`[ExpressService.createWaybillCode] deadlock retry attempt=${attempt} maxAttempts=${maxAttempts} code=${errorCode || 'UNKNOWN'} message=${errorMessage}`);
await new Promise(resolve => setTimeout(resolve, 50 * attempt));
return executeCreateWaybillTransactionWithRetry(attempt + 1);
}
};
this.ctx.logger.info('[ExpressService.createWaybillCode] DB 回写事务前', {
traceId,
orderCount: normalizedOrders.length,
});
const createWaybillResult = await executeCreateWaybillTransactionWithRetry(1);
this.ctx.logger.info('[ExpressService.createWaybillCode] DB 回写事务后', {
traceId,
successOrderCount: Array.isArray(createWaybillResult && createWaybillResult.orders)
? createWaybillResult.orders.length
: 0,
});
try {
if (Array.isArray(createWaybillResult.orders)
&& createWaybillResult.orders.length > 0
&& matchedPlatform
&& matchedPlatform.default_express_interface) {
try {
this.ctx.logger.info('[ExpressService.createWaybillCode] 平台后处理调用前', {
traceId,
platformInterface: matchedPlatform.default_express_interface,
orderCount: createWaybillResult.orders.length,
});
await this.dispatchWaybillAsyncPlatform(matchedPlatform.default_express_interface, {
matchedPlatform,
listByWarehousePlatformCode,
orders: createWaybillResult.orders,
trace_id: traceId,
});
this.ctx.logger.info('[ExpressService.createWaybillCode] 平台后处理调用后', {
traceId,
platformInterface: matchedPlatform.default_express_interface,
});
} catch (error) {
throw error;
}
}
} catch (error) {
const restoreRelationMap = new Map();
for (const order of Array.isArray(createWaybillResult.orders) ? createWaybillResult.orders : []) {
const orderDelivery = order && order.order_delivery;
const storeId = Number(order && order.store_id) || Number(orderDelivery && orderDelivery.store_id) || 0;
const warehouseId = Number(order && order.warehouse_id) || Number(orderDelivery && orderDelivery.warehouse_id) || 0;
if (!Number.isFinite(storeId) || storeId <= 0 || !Number.isFinite(warehouseId) || warehouseId <= 0) {
continue;
}
const relationKey = `${storeId}:${warehouseId}`;
const currentRelation = restoreRelationMap.get(relationKey) || {
store_id: storeId,
warehouse_id: warehouseId,
success_count: 0,
};
currentRelation.success_count += 1;
restoreRelationMap.set(relationKey, currentRelation);
}
console.error('运单后处理失败,准备回补锁定量:', error.message, 'restoreRelationList', Array.from(restoreRelationMap.values()));
this.ctx.logger.error('[ExpressService.createWaybillCode] 平台后处理异常,准备回补锁定量', {
traceId,
error: error && error.message ? error.message : `${error}`,
stack: error && error.stack ? error.stack : '',
restoreRelationList: Array.from(restoreRelationMap.values()),
});
if (restoreRelationMap.size > 0) {
const restoreRelationList = Array.from(restoreRelationMap.values());
const restoreRows = await storeWarehouseModel.findAll({
attributes: [ 'id', 'store_id', 'warehouse_id', 'print_quantity_locked' ],
where: {
[Op.or]: restoreRelationList.map(item => ({
store_id: item.store_id,
warehouse_id: item.warehouse_id,
})),
},
raw: true,
});
const restoreRowMap = new Map();
for (const row of Array.isArray(restoreRows) ? restoreRows : []) {
const relationKey = `${Number(row && row.store_id) || 0}:${Number(row && row.warehouse_id) || 0}`;
if (relationKey !== '0:0') {
restoreRowMap.set(relationKey, row);
}
}
const canIncrementLockedQuantity = typeof storeWarehouseModel.increment === 'function';
for (const item of restoreRelationList) {
const relationKey = `${item.store_id}:${item.warehouse_id}`;
const row = restoreRowMap.get(relationKey);
if (!row) {
continue;
}
const currentLockedQuantity = Math.max(0, Number(row.print_quantity_locked || 0));
const restoreQuantity = Math.min(currentLockedQuantity, item.success_count);
if (restoreQuantity <= 0) {
continue;
}
if (canIncrementLockedQuantity) {
await storeWarehouseModel.increment('print_quantity_locked', {
by: -restoreQuantity,
where: {
id: row.id,
},
});
continue;
}
await storeWarehouseModel.update({
print_quantity_locked: currentLockedQuantity - restoreQuantity,
}, {
where: {
id: row.id,
},
});
}
}
throw error;
}
this.ctx.logger.info('[ExpressService.createWaybillCode] 处理完成', {
traceId,
successOrderCount: Array.isArray(createWaybillResult && createWaybillResult.orders)
? createWaybillResult.orders.length
: 0,
});
return createWaybillResult;
}
}
module.exports = ExpressService;