695 lines
24 KiB
JavaScript
695 lines
24 KiB
JavaScript
'use strict';
|
|
|
|
const MainService = require('../main');
|
|
|
|
const OUTBOUND_STATUS = 'fin';
|
|
const OUTBOUND_STATUS_TIMEOUT = 'timeout';
|
|
const OUTBOUND_STEP = 4;
|
|
const OUTBOUND_SYNC_STEPS = [ OUTBOUND_STEP, 9 ];
|
|
const DISPATCH_LANE = 'm4';
|
|
const MAX_BATCH_SIZE = 1000;
|
|
const CURRENT_TABLE_PATTERN = /^wms_order_delivery_(\d+)$/;
|
|
const RETRYABLE_DATABASE_ERROR_CODES = new Set([ 1205, 1213, 'ER_LOCK_WAIT_TIMEOUT', 'ER_LOCK_DEADLOCK' ]);
|
|
const DEFAULT_OUTBOUND_STATUSES = [ OUTBOUND_STATUS, 'padding' ];
|
|
|
|
/**
|
|
* 订单出库后迁移到配送表的同步服务。
|
|
*/
|
|
class OrderDeliveryMigrationService extends MainService {
|
|
/**
|
|
* 同步当前仓库分表中已出库订单到配送表。
|
|
*
|
|
* @param {Object} data 请求参数。
|
|
* @param {number|Array<number|string>} [data.warehouseId] 单个仓库ID或仓库ID列表。
|
|
* @param {Array<number|string>} [data.warehouseIds] 仓库ID列表。
|
|
* @return {Promise<Object>} 同步结果。
|
|
*/
|
|
async syncOutboundOrdersToDelivery(data = {}) {
|
|
return this.syncOutboundOrdersByStatus(data, {
|
|
outboundStatuses: DEFAULT_OUTBOUND_STATUSES,
|
|
persistTimeoutState: true,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 重试出库超时订单并继续迁移到配送表。
|
|
*
|
|
* @param {Object} data 请求参数。
|
|
* @param {number|Array<number|string>} [data.warehouseId] 单个仓库ID或仓库ID列表。
|
|
* @param {Array<number|string>} [data.warehouseIds] 仓库ID列表。
|
|
* @return {Promise<Object>} 同步结果。
|
|
*/
|
|
async retryTimeoutOutboundOrdersToDelivery(data = {}) {
|
|
return this.syncOutboundOrdersByStatus(data, {
|
|
outboundStatuses: [ OUTBOUND_STATUS_TIMEOUT ],
|
|
persistTimeoutState: false,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 按指定出库状态同步订单到配送表。
|
|
*
|
|
* @param {Object} data 请求参数。
|
|
* @param {number|Array<number|string>} [data.warehouseId] 单个仓库ID或仓库ID列表。
|
|
* @param {Array<number|string>} [data.warehouseIds] 仓库ID列表。
|
|
* @param {Object} [options] 迁移控制参数。
|
|
* @param {Array<string>} [options.outboundStatuses] 需要迁移的出库状态。
|
|
* @param {number} [options.queryTimeoutMs] 单条数据库查询的超时时间。
|
|
* @param {number} [options.executionTimeoutMs] 单仓库批次的执行超时时间。
|
|
* @param {boolean} [options.persistTimeoutState] 失败后是否将源订单标记为出库超时。
|
|
* @return {Promise<Object>} 同步结果。
|
|
*/
|
|
async syncOutboundOrdersByStatus(data = {}, options = {}) {
|
|
const requestData = this.isPlainObject(data) ? data : {};
|
|
const explicitWarehouseIds = this.normalizeWarehouseIds(requestData);
|
|
const warehouseIds = explicitWarehouseIds.length > 0
|
|
? explicitWarehouseIds
|
|
: await this.listCurrentWarehouseIds();
|
|
|
|
const results = [];
|
|
let remaining = MAX_BATCH_SIZE;
|
|
let totalSelected = 0;
|
|
let totalCreated = 0;
|
|
let totalSkipped = 0;
|
|
let totalTimeout = 0;
|
|
|
|
for (const warehouseId of warehouseIds) {
|
|
if (remaining <= 0) {
|
|
break;
|
|
}
|
|
|
|
const batchLimit = Math.min(remaining, MAX_BATCH_SIZE);
|
|
const batchResult = await this.syncOutboundOrdersForWarehouse(warehouseId, batchLimit, options);
|
|
|
|
results.push(batchResult);
|
|
totalSelected += batchResult.selectedCount;
|
|
totalCreated += batchResult.createdCount;
|
|
totalSkipped += batchResult.skippedCount;
|
|
totalTimeout += Number(batchResult.timeoutCount || 0);
|
|
remaining -= batchResult.selectedCount;
|
|
}
|
|
|
|
return {
|
|
warehouseIds,
|
|
batchSize: MAX_BATCH_SIZE,
|
|
outboundStatuses: this.normalizeOutboundStatuses(options.outboundStatuses),
|
|
totalSelected,
|
|
totalCreated,
|
|
totalSkipped,
|
|
totalTimeout,
|
|
results,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 规范化仓库ID列表。
|
|
*
|
|
* @param {Object} data 请求参数。
|
|
* @return {Array<number>} 仓库ID列表。
|
|
*/
|
|
normalizeWarehouseIds(data = {}) {
|
|
if (!this.isPlainObject(data)) {
|
|
return [];
|
|
}
|
|
|
|
const candidateValues = Array.isArray(data.warehouseIds)
|
|
? data.warehouseIds
|
|
: [ data.warehouseId ?? data.warehouse_id ].filter(value => value !== undefined && value !== null && value !== '');
|
|
|
|
return Array.from(new Set(candidateValues
|
|
.map(value => Number(value))
|
|
.filter(value => Number.isFinite(value) && value > 0)))
|
|
.sort((left, right) => left - right);
|
|
}
|
|
|
|
/**
|
|
* 获取当前库中存在的订单工作台仓库ID。
|
|
*
|
|
* @return {Promise<Array<number>>} 仓库ID列表。
|
|
*/
|
|
async listCurrentWarehouseIds() {
|
|
const factory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
|
|
|
|
if (!factory || typeof factory.listManagedTableNames !== 'function') {
|
|
return [];
|
|
}
|
|
|
|
const tableNames = await factory.listManagedTableNames();
|
|
|
|
return Array.from(new Set((Array.isArray(tableNames) ? tableNames : [])
|
|
.map(tableName => {
|
|
const matched = CURRENT_TABLE_PATTERN.exec(String(tableName || ''));
|
|
return matched ? Number(matched[1]) : null;
|
|
})
|
|
.filter(value => Number.isFinite(value) && value > 0)))
|
|
.sort((left, right) => left - right);
|
|
}
|
|
|
|
/**
|
|
* 规范化需要迁移的出库状态。
|
|
*
|
|
* @param {Array<string>|string} outboundStatuses 目标状态。
|
|
* @return {Array<string>} 规范化后的状态列表。
|
|
*/
|
|
normalizeOutboundStatuses(outboundStatuses = DEFAULT_OUTBOUND_STATUSES) {
|
|
const candidates = Array.isArray(outboundStatuses)
|
|
? outboundStatuses
|
|
: [ outboundStatuses ];
|
|
|
|
const normalizedStatuses = Array.from(new Set(candidates
|
|
.map(value => String(value || '').trim())
|
|
.filter(Boolean)));
|
|
|
|
return normalizedStatuses.length > 0 ? normalizedStatuses : DEFAULT_OUTBOUND_STATUSES;
|
|
}
|
|
|
|
/**
|
|
* 构造 Sequelize 查询参数。
|
|
*
|
|
* @param {Object|null} transaction 事务对象。
|
|
* @param {number} [queryTimeoutMs] 查询超时时间。
|
|
* @return {Object} Sequelize 查询参数。
|
|
*/
|
|
buildMigrationQueryOptions(transaction, queryTimeoutMs) {
|
|
const queryOptions = {};
|
|
|
|
if (transaction) {
|
|
queryOptions.transaction = transaction;
|
|
}
|
|
|
|
const normalizedTimeoutMs = Number(queryTimeoutMs);
|
|
if (Number.isFinite(normalizedTimeoutMs) && normalizedTimeoutMs > 0) {
|
|
queryOptions.timeout = normalizedTimeoutMs;
|
|
}
|
|
|
|
return queryOptions;
|
|
}
|
|
|
|
/**
|
|
* 识别可重试的出库迁移错误。
|
|
*
|
|
* @param {Error} error 运行时错误。
|
|
* @return {{ retryable: boolean, category: string, message: string }} 错误分类结果。
|
|
*/
|
|
getOutboundMigrationErrorInfo(error) {
|
|
const errorMessage = String(error && error.message || '');
|
|
const errorName = String(error && error.name || '');
|
|
const parentError = error && error.parent ? error.parent : null;
|
|
const errorCode = parentError && (parentError.code || parentError.errno)
|
|
? parentError.code || parentError.errno
|
|
: error && (error.code || error.errno);
|
|
const normalizedMessage = errorMessage.toLowerCase();
|
|
|
|
if (errorName === 'SequelizeTimeoutError' || errorName === 'TimeoutError' || errorCode === 'ETIMEDOUT') {
|
|
return {
|
|
retryable: true,
|
|
category: 'timeout',
|
|
message: errorMessage,
|
|
};
|
|
}
|
|
|
|
if (errorName === 'SequelizeDatabaseError') {
|
|
if (normalizedMessage.includes('lock wait timeout')) {
|
|
return {
|
|
retryable: true,
|
|
category: 'lock_wait_timeout',
|
|
message: errorMessage,
|
|
};
|
|
}
|
|
|
|
if (RETRYABLE_DATABASE_ERROR_CODES.has(errorCode) || normalizedMessage.includes('deadlock')) {
|
|
return {
|
|
retryable: true,
|
|
category: 'deadlock',
|
|
message: errorMessage,
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
retryable: false,
|
|
category: 'other',
|
|
message: errorMessage,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 将指定仓库内的源订单标记为出库超时。
|
|
*
|
|
* @param {number} warehouseId 仓库ID。
|
|
* @param {Array<number>} orderIds 源订单ID列表。
|
|
* @param {number} [queryTimeoutMs] 更新语句超时时间。
|
|
* @return {Promise<number>} 受影响行数。
|
|
*/
|
|
async markOutboundOrdersTimeout(warehouseId, orderIds, queryTimeoutMs) {
|
|
const normalizedWarehouseId = Number(warehouseId);
|
|
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
|
|
.map(value => Number(value))
|
|
.filter(value => Number.isFinite(value) && value > 0)));
|
|
|
|
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
|
throw new Error('仓库ID不能为空');
|
|
}
|
|
|
|
if (normalizedOrderIds.length === 0) {
|
|
return 0;
|
|
}
|
|
|
|
const orderFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
|
|
|
|
if (!orderFactory || typeof orderFactory.getCurrentModel !== 'function') {
|
|
throw new Error('订单工厂未初始化');
|
|
}
|
|
|
|
const sourceOrderModel = await orderFactory.getCurrentModel(normalizedWarehouseId);
|
|
const { Op } = this.ctx.app.Sequelize;
|
|
const updateValues = {
|
|
outbound_status: OUTBOUND_STATUS_TIMEOUT,
|
|
updated_at: new Date(),
|
|
};
|
|
const updateResult = await sourceOrderModel.update(updateValues, {
|
|
where: {
|
|
warehouse_id: normalizedWarehouseId,
|
|
id: {
|
|
[Op.in]: normalizedOrderIds,
|
|
},
|
|
},
|
|
...this.buildMigrationQueryOptions(null, queryTimeoutMs),
|
|
});
|
|
|
|
return Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
|
|
}
|
|
|
|
/**
|
|
* 构造配送表去重键。
|
|
*
|
|
* @param {Object} row 订单行数据。
|
|
* @return {string} 去重键。
|
|
*/
|
|
buildDispatchKey(row) {
|
|
if (!this.isPlainObject(row)) {
|
|
return '';
|
|
}
|
|
|
|
const deliveryOrderCode = String(row.delivery_order_code || '').trim();
|
|
const storeId = String(row.store_id || '').trim();
|
|
const warehouseId = String(row.warehouse_id || '').trim();
|
|
|
|
if (!deliveryOrderCode || !storeId || !warehouseId) {
|
|
return '';
|
|
}
|
|
|
|
return `${deliveryOrderCode}::${storeId}::${warehouseId}`;
|
|
}
|
|
|
|
/**
|
|
* 构造配送表插入行。
|
|
*
|
|
* @param {Object} row 当前订单工作台数据。
|
|
* @return {Object} 可写入配送表的数据。
|
|
*/
|
|
buildDispatchRow(row) {
|
|
const payload = { ...(row || {}) };
|
|
delete payload.dispatch_lane;
|
|
return { ...payload, dispatch_lane: DISPATCH_LANE };
|
|
}
|
|
|
|
/**
|
|
* 构造商品明细迁移行。
|
|
*
|
|
* @param {Object} row 当前订单商品明细行。
|
|
* @param {number} targetOrderId 配送表订单ID。
|
|
* @return {Object} 可写入配送明细表的数据。
|
|
*/
|
|
buildDispatchItemRow(row, targetOrderId) {
|
|
return {
|
|
...(row || {}),
|
|
order_id: targetOrderId,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 获取订单与商品明细迁移所需的模型。
|
|
*
|
|
* @param {number} warehouseId 仓库ID。
|
|
* @return {Promise<Object>} 迁移模型集合。
|
|
*/
|
|
async getMigrationModels(warehouseId) {
|
|
const orderFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
|
|
const itemsFactory = this.ctx.model && this.ctx.model.OrderItemsFactory;
|
|
|
|
if (!orderFactory || typeof orderFactory.getCurrentModel !== 'function' || typeof orderFactory.getDispatchModel !== 'function') {
|
|
throw new Error('订单工厂未初始化');
|
|
}
|
|
|
|
if (!itemsFactory || typeof itemsFactory.getCurrentModel !== 'function' || typeof itemsFactory.getDispatchModel !== 'function') {
|
|
throw new Error('订单商品工厂未初始化');
|
|
}
|
|
|
|
return {
|
|
sourceOrderModel: await orderFactory.getCurrentModel(warehouseId),
|
|
targetOrderModel: await orderFactory.getDispatchModel(warehouseId),
|
|
sourceItemModel: await itemsFactory.getCurrentModel(warehouseId),
|
|
targetItemModel: await itemsFactory.getDispatchModel(warehouseId),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 将配送表订单行转换为订单ID映射。
|
|
*
|
|
* @param {Array<Object>} rows 配送表订单行。
|
|
* @return {Map<string, number>} 业务键到订单ID的映射。
|
|
*/
|
|
buildTargetOrderIdMap(rows) {
|
|
return new Map((Array.isArray(rows) ? rows : [])
|
|
.map(row => {
|
|
const key = this.buildDispatchKey(row);
|
|
const orderId = Number(row && row.id);
|
|
|
|
if (!key || !Number.isFinite(orderId) || orderId <= 0) {
|
|
return null;
|
|
}
|
|
|
|
return [ key, orderId ];
|
|
})
|
|
.filter(Boolean));
|
|
}
|
|
|
|
/**
|
|
* 同步指定仓库的已出库订单。
|
|
*
|
|
* @param {number|string} warehouseId 仓库ID。
|
|
* @param {number} [limit=1000] 单次处理数量上限。
|
|
* @param {Object} [options] 迁移控制参数。
|
|
* @param {Array<string>} [options.outboundStatuses] 需要迁移的出库状态。
|
|
* @param {number} [options.queryTimeoutMs] 单条数据库查询的超时时间。
|
|
* @param {number} [options.executionTimeoutMs] 单仓库批次的执行超时时间。
|
|
* @param {boolean} [options.persistTimeoutState] 失败后是否将源订单标记为出库超时。
|
|
* @return {Promise<Object>} 同步结果。
|
|
*/
|
|
async syncOutboundOrdersForWarehouse(warehouseId, limit = MAX_BATCH_SIZE, options = {}) {
|
|
const normalizedWarehouseId = Number(warehouseId);
|
|
|
|
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
|
throw new Error('仓库ID不能为空');
|
|
}
|
|
|
|
const batchLimit = Math.min(
|
|
Math.max(Number(limit) || MAX_BATCH_SIZE, 1),
|
|
MAX_BATCH_SIZE
|
|
);
|
|
const outboundStatuses = this.normalizeOutboundStatuses(options.outboundStatuses);
|
|
const queryTimeoutMs = Number(options.queryTimeoutMs);
|
|
const executionTimeoutMs = Number(options.executionTimeoutMs);
|
|
const persistTimeoutState = Boolean(options.persistTimeoutState);
|
|
const deadlineAt = Number.isFinite(executionTimeoutMs) && executionTimeoutMs > 0
|
|
? Date.now() + executionTimeoutMs
|
|
: 0;
|
|
|
|
// 序列表初始化可能执行 DDL(隐式提交),必须在事务外完成。
|
|
// 初始化失败直接终止迁移:位置指针与配送表写入必须在同一事务内原子完成,
|
|
// 没有序列表则无法保证索引一致,宁可迁移失败重试也不产生错位指针。
|
|
await this.ctx.model.OrderDeliveryFactory.ensureLocationSequenceTable(normalizedWarehouseId);
|
|
|
|
const transaction = await this.ctx.model.transaction();
|
|
const { Op } = this.ctx.app.Sequelize;
|
|
let sourceRows = [];
|
|
let selectedSourceOrderIds = [];
|
|
|
|
const assertMigrationDeadline = stage => {
|
|
if (deadlineAt > 0 && Date.now() > deadlineAt) {
|
|
const timeoutError = new Error(`仓库 ${normalizedWarehouseId} ${stage} 执行超时`);
|
|
timeoutError.code = 'OUTBOUND_MIGRATION_TIMEOUT';
|
|
throw timeoutError;
|
|
}
|
|
};
|
|
|
|
try {
|
|
assertMigrationDeadline('出库迁移');
|
|
const {
|
|
sourceOrderModel,
|
|
targetOrderModel,
|
|
sourceItemModel,
|
|
targetItemModel,
|
|
} = await this.getMigrationModels(normalizedWarehouseId);
|
|
|
|
assertMigrationDeadline('查询源订单');
|
|
sourceRows = await sourceOrderModel.findAll({
|
|
where: {
|
|
warehouse_id: normalizedWarehouseId,
|
|
outbound_status: {
|
|
[Op.in]: outboundStatuses,
|
|
},
|
|
step: {
|
|
[Op.in]: OUTBOUND_SYNC_STEPS,
|
|
},
|
|
},
|
|
order: [[ 'id', 'ASC' ]],
|
|
limit: batchLimit,
|
|
raw: true,
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
|
|
selectedSourceOrderIds = Array.from(new Set((Array.isArray(sourceRows) ? sourceRows : [])
|
|
.map(row => Number(row && row.id))
|
|
.filter(value => Number.isFinite(value) && value > 0)));
|
|
|
|
if (!Array.isArray(sourceRows) || sourceRows.length === 0) {
|
|
await transaction.commit();
|
|
|
|
return {
|
|
warehouseId: normalizedWarehouseId,
|
|
selectedCount: 0,
|
|
createdCount: 0,
|
|
skippedCount: 0,
|
|
timeoutCount: 0,
|
|
};
|
|
}
|
|
|
|
const invalidSourceRows = sourceRows.filter(row => !this.buildDispatchKey(row));
|
|
|
|
if (invalidSourceRows.length > 0) {
|
|
const invalidRowIds = invalidSourceRows
|
|
.map(row => Number(row && row.id))
|
|
.filter(value => Number.isFinite(value) && value > 0);
|
|
|
|
throw new Error(`选中的源订单存在缺少 delivery_order_code/store_id/warehouse_id 的记录${invalidRowIds.length > 0 ? `: ${invalidRowIds.join(', ')}` : ''}`);
|
|
}
|
|
|
|
const validSourceRows = sourceRows;
|
|
const sourceOrderRowMap = new Map(validSourceRows
|
|
.map(row => [ Number(row.id), row ])
|
|
.filter(([ rowId, row ]) => Number.isFinite(rowId) && rowId > 0 && this.buildDispatchKey(row)));
|
|
let deliveryOrderCodes = Array.from(new Set(validSourceRows
|
|
.map(row => String(row.delivery_order_code || '').trim())
|
|
.filter(Boolean)));
|
|
const sourceOrderIds = Array.from(sourceOrderRowMap.keys());
|
|
const orderCodeMap = new Map(); // source order_id → renamed delivery_order_code
|
|
|
|
let existingRows = [];
|
|
if (deliveryOrderCodes.length > 0) {
|
|
assertMigrationDeadline('查询配送表订单');
|
|
existingRows = await targetOrderModel.findAll({
|
|
where: {
|
|
warehouse_id: normalizedWarehouseId,
|
|
delivery_order_code: {
|
|
[Op.in]: deliveryOrderCodes,
|
|
},
|
|
},
|
|
raw: true,
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
}
|
|
|
|
const existingKeySet = new Set((Array.isArray(existingRows) ? existingRows : [])
|
|
.map(row => this.buildDispatchKey(row))
|
|
.filter(Boolean));
|
|
|
|
const rowsToCreate = [];
|
|
for (const row of validSourceRows) {
|
|
let tryCode = String(row.delivery_order_code || '').trim();
|
|
const storeId = String(row.store_id || '').trim();
|
|
const warehouseId = String(row.warehouse_id || '').trim();
|
|
const originalKey = `${tryCode}::${storeId}::${warehouseId}`;
|
|
let seq = 2;
|
|
|
|
while (existingKeySet.has(`${tryCode}::${storeId}::${warehouseId}`)) {
|
|
tryCode = `${String(row.delivery_order_code || '').trim()}-${seq}`;
|
|
seq++;
|
|
}
|
|
|
|
const newKey = `${tryCode}::${storeId}::${warehouseId}`;
|
|
if (newKey !== originalKey) {
|
|
this.ctx.logger.info(
|
|
`[sync-outbound-orders-to-delivery] delivery_order_code 冲突,重命名: ${originalKey} → ${newKey}`
|
|
);
|
|
orderCodeMap.set(Number(row.id), tryCode);
|
|
}
|
|
existingKeySet.add(newKey);
|
|
|
|
const modifiedRow = tryCode !== String(row.delivery_order_code || '').trim()
|
|
? { ...row, delivery_order_code: tryCode }
|
|
: row;
|
|
|
|
rowsToCreate.push(this.buildDispatchRow(modifiedRow));
|
|
}
|
|
|
|
for (const renamedCode of orderCodeMap.values()) {
|
|
deliveryOrderCodes.push(renamedCode);
|
|
}
|
|
deliveryOrderCodes = Array.from(new Set(deliveryOrderCodes.filter(Boolean)));
|
|
|
|
if (rowsToCreate.length > 0) {
|
|
assertMigrationDeadline('创建配送表订单');
|
|
await targetOrderModel.bulkCreate(rowsToCreate, {
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
|
|
// 更新序列表位置指针:current → dispatch。与上方 bulkCreate 处于同一事务,
|
|
// 任一步失败整体回滚,保证配送表数据与位置索引原子一致(存量订单自动补录,
|
|
// 显式 id 大于序列表水位时 MySQL 会自动推进,后续发号不会与存量 id 冲突)。
|
|
const locationFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
|
|
if (!locationFactory || typeof locationFactory.updateOrderLocation !== 'function') {
|
|
throw new Error('订单工厂缺少 updateOrderLocation,无法同步序列表位置指针');
|
|
}
|
|
for (const row of rowsToCreate) {
|
|
await locationFactory.updateOrderLocation(
|
|
Number(row.id),
|
|
normalizedWarehouseId,
|
|
'dispatch',
|
|
transaction
|
|
);
|
|
}
|
|
}
|
|
|
|
assertMigrationDeadline('查询配送表订单');
|
|
const targetRows = deliveryOrderCodes.length > 0
|
|
? await targetOrderModel.findAll({
|
|
where: {
|
|
warehouse_id: normalizedWarehouseId,
|
|
delivery_order_code: {
|
|
[Op.in]: deliveryOrderCodes,
|
|
},
|
|
},
|
|
raw: true,
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
})
|
|
: [];
|
|
const targetOrderIdMap = this.buildTargetOrderIdMap(targetRows);
|
|
|
|
if (sourceOrderIds.length > 0) {
|
|
assertMigrationDeadline('查询商品明细');
|
|
const sourceItems = await sourceItemModel.findAll({
|
|
where: {
|
|
order_id: {
|
|
[Op.in]: sourceOrderIds,
|
|
},
|
|
},
|
|
order: [[ 'id', 'ASC' ]],
|
|
raw: true,
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
|
|
const validSourceItems = Array.isArray(sourceItems)
|
|
? sourceItems.filter(item => Number.isFinite(Number(item && item.id)))
|
|
: [];
|
|
|
|
const rowsToCreateItems = validSourceItems.map(item => {
|
|
const sourceOrder = sourceOrderRowMap.get(Number(item.order_id));
|
|
const renamedCode = orderCodeMap.get(Number(item.order_id));
|
|
const key = renamedCode
|
|
? `${renamedCode}::${String(sourceOrder.store_id || '').trim()}::${String(sourceOrder.warehouse_id || '').trim()}`
|
|
: this.buildDispatchKey(sourceOrder);
|
|
const targetOrderId = targetOrderIdMap.get(key);
|
|
|
|
if (!Number.isFinite(targetOrderId) || targetOrderId <= 0) {
|
|
throw new Error(`无法找到订单 ${item.order_id} 对应的配送表订单ID`);
|
|
}
|
|
|
|
return this.buildDispatchItemRow(item, targetOrderId);
|
|
});
|
|
|
|
if (rowsToCreateItems.length > 0) {
|
|
assertMigrationDeadline('创建商品明细');
|
|
await targetItemModel.bulkCreate(rowsToCreateItems, {
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
}
|
|
|
|
assertMigrationDeadline('删除源商品明细');
|
|
await sourceItemModel.destroy({
|
|
where: {
|
|
id: {
|
|
[Op.in]: validSourceItems.map(item => Number(item.id)).filter(value => Number.isFinite(value) && value > 0),
|
|
},
|
|
},
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
}
|
|
|
|
if (sourceOrderIds.length > 0) {
|
|
assertMigrationDeadline('删除源订单');
|
|
await sourceOrderModel.destroy({
|
|
where: {
|
|
id: {
|
|
[Op.in]: sourceOrderIds,
|
|
},
|
|
},
|
|
...this.buildMigrationQueryOptions(transaction, queryTimeoutMs),
|
|
});
|
|
}
|
|
|
|
await transaction.commit();
|
|
|
|
return {
|
|
warehouseId: normalizedWarehouseId,
|
|
selectedCount: sourceRows.length,
|
|
createdCount: rowsToCreate.length,
|
|
skippedCount: sourceRows.length - rowsToCreate.length,
|
|
timeoutCount: 0,
|
|
};
|
|
} catch (error) {
|
|
await transaction.rollback();
|
|
|
|
const migrationErrorInfo = this.getOutboundMigrationErrorInfo(error);
|
|
const shouldPersistTimeoutState = persistTimeoutState && migrationErrorInfo.retryable && selectedSourceOrderIds.length > 0;
|
|
|
|
if (shouldPersistTimeoutState) {
|
|
const timeoutCount = await this.markOutboundOrdersTimeout(
|
|
normalizedWarehouseId,
|
|
selectedSourceOrderIds,
|
|
queryTimeoutMs
|
|
);
|
|
|
|
return {
|
|
warehouseId: normalizedWarehouseId,
|
|
selectedCount: sourceRows.length,
|
|
createdCount: 0,
|
|
skippedCount: 0,
|
|
timeoutCount,
|
|
retryableFailure: true,
|
|
retryableFailureType: migrationErrorInfo.category,
|
|
retryableFailureMessage: migrationErrorInfo.message,
|
|
};
|
|
}
|
|
|
|
if (migrationErrorInfo.retryable) {
|
|
return {
|
|
warehouseId: normalizedWarehouseId,
|
|
selectedCount: sourceRows.length,
|
|
createdCount: 0,
|
|
skippedCount: 0,
|
|
timeoutCount: 0,
|
|
retryableFailure: true,
|
|
retryableFailureType: migrationErrorInfo.category,
|
|
retryableFailureMessage: migrationErrorInfo.message,
|
|
};
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = OrderDeliveryMigrationService;
|