oms/backend/database/migrations/20260916050100-migrate-legacy-orders-to-order-status.js
liufumingren 6c03a20364 feat(backend): 订单状态分表、WMS 推送与归档
- 新增 order_index 索引表 + 6 张同构状态表(待审核/异常/委外中/配送/已作废/已取消)与历史表,
  订单 ID 全局唯一,状态由业务事务推动:审核、驳回、取消、作废、恢复、归档
- 明细表 order_status_items、收件人文本智能解析、批量切换仓库/店铺并刷新快照
- WMS deliveryorder.create 推送(单条/批量)、推送失败定时重试、订单归档定时任务
- 迁移:建表、旧发货单数据迁入新表、菜单合并与迁移记录清理
- routes / swagger contract 补充订单状态接口

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-30 23:06:18 +08:00

364 lines
14 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/**
* 老数据搬迁:原订单表 orders(含 order_items)与发货单 order_deliveries(含 order_delivery_items)
* → 订单状态表(order_index + order_status_* + order_status_items)。
*
* 老表数据不动(保留可回溯),搬迁结果按 `legacy_source` + `legacy_order_id`(明细用 legacy_order_item_id)标记,
* 可幂等重复执行(已迁过的行跳过)。
*
* 状态映射(老数值 → 新流程状态,原值写入 legacy_status):
* - orders.status:1待处理 → pending、2处理中 → outsourcing、3已完成 → delivery、4已取消 → canceled
* - order_deliveries.status:1待处理 → pending、2已审核 → outsourcing、3已推送 → outsourcing、
* 4已完成 → delivery、5已作废 → void、9已取消 → canceled
* (新流程里「审核后即入委外/推送队列」,故老 2/3 都落在委外中)
*
* 字段映射(详见 app/lib/orderFields.js 头部注释):
* - orders.order_no、order_deliveries.delivery_order_code → order_no
* - orders.receiver(JSON {name,phone,address}) → receiver / tel / address
* - order_deliveries.name → receiver;source_order_codes → parent_order_no(截断 50)
* - 明细:order_delivery_items.order_delivery_id / order_items.order_id → order_status_items.order_id(新的订单 ID)
*
* 执行:npm run migration:up
*/
const { ORDER_STATUS, ORDER_STATUS_ORDER, ORDER_TABLE_BY_STATUS, ORDER_INDEX_TABLE } = require('../../app/lib/orderStatus');
const { businessFields, itemFields } = require('../../app/lib/orderFields');
/** 全部状态表(含作废 / 取消 / 历史),顺序与 order_index.current_status 取值一致 */
const ALL_STATUS_TABLES = ORDER_STATUS_ORDER.map(status => ORDER_TABLE_BY_STATUS[status]);
/** 老状态 → 新流程状态 */
const ORDER_STATUS_MAP = { 1: ORDER_STATUS.PENDING, 2: ORDER_STATUS.OUTSOURCING, 3: ORDER_STATUS.DELIVERY, 4: ORDER_STATUS.CANCELED };
const DELIVERY_STATUS_MAP = {
1: ORDER_STATUS.PENDING,
2: ORDER_STATUS.OUTSOURCING,
3: ORDER_STATUS.OUTSOURCING,
4: ORDER_STATUS.DELIVERY,
5: ORDER_STATUS.VOID,
9: ORDER_STATUS.CANCELED,
};
/**
* 字符串截断(按列长)
* @param {*} value 原值
* @param {Number} len 最大长度
* @return {String|null} 截断结果
*/
function str(value, len) {
if (value === null || value === undefined) return null;
const text = String(value);
return len ? text.slice(0, len) : text;
}
/**
* 解析老 orders.receiver(JSON 字符串或对象)
* @param {*} value 原值
* @return {Object} { name, phone, address }
*/
function parseReceiver(value) {
if (!value) return {};
if (typeof value === 'object') return value;
try {
return JSON.parse(value) || {};
} catch (e) {
return {};
}
}
/**
* 按字段定义过滤对象(只保留目标表存在的列,未给的用 undefined 跳过)
* @param {Object} Sequelize sequelize 构造函数
* @param {Object} defs 字段定义
* @param {Object} row 源数据
* @return {Object} 过滤后的列值
*/
function pickByDefs(Sequelize, defs, row) {
const out = {};
for (const [ name ] of Object.entries(defs)) {
if (row[name] === undefined) continue;
out[name] = row[name];
}
return out;
}
/**
* 读取已搬迁的来源标记(幂等判断)
* @param {Object} queryInterface sequelize queryInterface
* @return {Promise<Set<String>>} "source#id" 集合
*/
async function migratedKeys(queryInterface) {
const keys = new Set();
for (const table of ALL_STATUS_TABLES) {
const [ rows ] = await queryInterface.sequelize.query(
`SELECT legacy_source, legacy_order_id FROM \`${table}\` WHERE legacy_source IS NOT NULL`
);
for (const row of rows) keys.add(`${row.legacy_source}#${row.legacy_order_id}`);
}
return keys;
}
/**
* 搬迁单条主记录:确保索引表行存在(取订单 ID)+ 写入目标状态表
* @param {Object} ctx 上下文 { queryInterface, Sequelize, statusDefs }
* @param {Object} p 参数 { source, row, status, orderNo, parentOrderNo, principalId, fields }
* @return {Promise<Number>} 新订单 ID
*/
async function insertOrder(ctx, p) {
const { queryInterface, Sequelize, statusDefs } = ctx;
const { sequelize } = queryInterface;
const table = ORDER_TABLE_BY_STATUS[p.status];
const orderNo = str(p.orderNo, 50);
const parentOrderNo = str(p.parentOrderNo, 50);
// 同主体同单号已存在(上次中断留下的半成品 / 人工建过的同号单)→ 复用其订单 ID,避免唯一键冲突
const [ found ] = await sequelize.query(
`SELECT id FROM \`${ORDER_INDEX_TABLE}\` WHERE principal_id = ? AND order_no = ? LIMIT 1`,
{ replacements: [ p.principalId, orderNo ] }
);
let newId;
if (found.length) {
newId = Number(found[0].id);
await sequelize.query(
`UPDATE \`${ORDER_INDEX_TABLE}\` SET parent_order_no = ?, current_table = ?, current_status = ? WHERE id = ?`,
{ replacements: [ parentOrderNo, p.status, p.status, newId ] }
);
} else {
// 显式取 ID:不依赖各 driver 对 INSERT 返回值(insertId)的差异
const [ seq ] = await sequelize.query(`SELECT COALESCE(MAX(id), 0) + 1 AS id FROM \`${ORDER_INDEX_TABLE}\``);
newId = Number(seq[0].id);
await sequelize.query(
`INSERT INTO \`${ORDER_INDEX_TABLE}\` (id, order_no, parent_order_no, principal_id, current_table, current_status)
VALUES (?, ?, ?, ?, ?, ?)`,
{ replacements: [ newId, orderNo, parentOrderNo, p.principalId, p.status, p.status ] }
);
}
// 该 ID 已落在其它状态表 → 冲突,跳过,避免主键冲突或错乱
const occupied = await findOccupiedTable(sequelize, newId, table);
if (occupied) {
console.warn(`[order] 订单 ID ${newId}(${orderNo})已存在于 ${occupied},跳过该单搬迁`);
return null;
}
await insertRow(sequelize, table, {
...pickByDefs(Sequelize, statusDefs, p.fields),
id: newId,
order_no: orderNo,
parent_order_no: parentOrderNo,
principal_id: p.principalId,
status: p.status,
legacy_source: p.source,
legacy_order_id: p.row.id,
});
return newId;
}
/**
* 该订单 ID 是否已存在于除 expectTable 之外的状态表
* @param {Object} sequelize sequelize 实例
* @param {Number} id 订单 ID
* @param {String} expectTable 允许存在的目标表
* @return {Promise<String|null>} 冲突表名,无冲突返回 null
*/
async function findOccupiedTable(sequelize, id, expectTable) {
for (const table of ALL_STATUS_TABLES) {
if (table === expectTable) continue;
const [ rows ] = await sequelize.query(`SELECT id FROM \`${table}\` WHERE id = ? LIMIT 1`, { replacements: [ id ] });
if (rows.length) return table;
}
return null;
}
/**
* 归一化参数值:Sequelize 的位置参数只支持标量,JSON 列的对象 / 数组先转 JSON 字符串
* @param {*} value 原值
* @return {*} 可作为 ? 参数的值
*/
function toSqlValue(value) {
if (value === null || value === undefined) return value;
if (value instanceof Date || Buffer.isBuffer(value)) return value;
if (typeof value === 'object') return JSON.stringify(value);
return value;
}
/**
* 通用写入:过滤 undefined,按列拼 INSERT
* @param {Object} sequelize sequelize 实例
* @param {String} table 目标表
* @param {Object} values 列值
* @return {Promise<void>} 无
*/
async function insertRow(sequelize, table, values) {
const filtered = {};
for (const [ key, value ] of Object.entries(values)) {
if (value === undefined) continue;
filtered[key] = toSqlValue(value);
}
const cols = Object.keys(filtered);
if (!cols.length) return;
await sequelize.query(
`INSERT INTO \`${table}\` (${cols.map(c => `\`${c}\``).join(', ')}) VALUES (${cols.map(() => '?').join(', ')})`,
{ replacements: cols.map(c => filtered[c]) }
);
}
module.exports = {
async up(queryInterface, Sequelize) {
const { sequelize } = queryInterface;
const statusDefs = businessFields(Sequelize, ORDER_STATUS.PENDING);
const itemDefs = itemFields(Sequelize);
const done = await migratedKeys(queryInterface);
const ctx = { queryInterface, Sequelize, statusDefs };
const orderIdByLegacy = new Map(); // "source#id" → 新订单 ID
let migrated = 0;
// 1) 原订单表 orders
const [ orders ] = await sequelize.query('SELECT * FROM `orders`');
for (const row of orders) {
if (done.has(`orders#${row.id}`)) continue;
const status = ORDER_STATUS_MAP[Number(row.status)] || ORDER_STATUS.PENDING;
const receiver = parseReceiver(row.receiver);
const newId = await insertOrder(ctx, {
source: 'orders',
row,
status,
orderNo: str(row.order_no, 50),
parentOrderNo: null,
principalId: Number(row.principal_id),
fields: {
...pickByDefs(Sequelize, statusDefs, row),
receiver: str(receiver.name, 50),
tel: str(receiver.phone, 50),
address: str(receiver.address, 255),
detail_address: str(receiver.address, 500),
legacy_status: row.status,
status,
},
});
if (!newId) continue;
orderIdByLegacy.set(`orders#${row.id}`, newId);
migrated++;
}
// 2) 原订单明细 order_items → order_status_items
const [ orderItems ] = await sequelize.query('SELECT * FROM `order_items`');
for (const row of orderItems) {
const orderId = orderIdByLegacy.get(`orders#${row.order_id}`) ||
(await findMigratedOrderId(sequelize, 'orders', row.order_id));
if (!orderId) continue;
const exists = await itemExists(sequelize, 'order_items', row.id);
if (exists) continue;
const values = {
...pickByDefs(Sequelize, itemDefs, row),
principal_id: Number(row.principal_id),
order_id: orderId,
shop_id: row.shop_id,
item_name: str(row.name, 255),
order_line_no: String(row.id).slice(0, 20),
legacy_source: 'order_items',
legacy_order_item_id: row.id,
};
await insertRow(sequelize, 'order_status_items', values);
migrated++;
}
// 3) 发货单 order_deliveries
const [ deliveries ] = await sequelize.query('SELECT * FROM `order_deliveries`');
for (const row of deliveries) {
if (done.has(`order_deliveries#${row.id}`)) continue;
const status = DELIVERY_STATUS_MAP[Number(row.status)] || ORDER_STATUS.PENDING;
const newId = await insertOrder(ctx, {
source: 'order_deliveries',
row,
status,
orderNo: str(row.delivery_order_code, 50),
parentOrderNo: str(row.source_order_codes, 50),
principalId: Number(row.principal_id),
fields: {
...pickByDefs(Sequelize, statusDefs, row),
receiver: str(row.name, 50),
legacy_status: row.status,
status,
},
});
if (!newId) continue;
orderIdByLegacy.set(`order_deliveries#${row.id}`, newId);
migrated++;
}
// 4) 发货单明细 order_delivery_items → order_status_items
const [ deliveryItems ] = await sequelize.query('SELECT * FROM `order_delivery_items`');
for (const row of deliveryItems) {
const orderId = orderIdByLegacy.get(`order_deliveries#${row.order_delivery_id}`) ||
(await findMigratedOrderId(sequelize, 'order_deliveries', row.order_delivery_id));
if (!orderId) continue;
if (await itemExists(sequelize, 'order_delivery_items', row.id)) continue;
const values = {
...pickByDefs(Sequelize, itemDefs, row),
principal_id: Number(row.principal_id),
order_id: orderId,
legacy_source: 'order_delivery_items',
legacy_order_item_id: row.id,
};
await insertRow(sequelize, 'order_status_items', values);
migrated++;
}
console.log(`[order] 老数据搬迁完成:新增 ${migrated} 条(源表行数 orders=${orders.length} / order_items=${orderItems.length} / order_deliveries=${deliveries.length} / order_delivery_items=${deliveryItems.length})`);
},
async down(queryInterface) {
const { sequelize } = queryInterface;
const sources = [ 'orders', 'order_deliveries' ];
const itemSources = [ 'order_items', 'order_delivery_items' ];
const otherTables = ALL_STATUS_TABLES;
const ids = [];
for (const table of otherTables) {
const [ rows ] = await sequelize.query(`SELECT id FROM \`${table}\` WHERE legacy_source IN (?)`, { replacements: [ sources ] });
for (const row of rows) ids.push(row.id);
}
await sequelize.query('DELETE FROM `order_status_items` WHERE legacy_source IN (?)', { replacements: [ itemSources ] });
for (const table of otherTables) {
await sequelize.query(`DELETE FROM \`${table}\` WHERE legacy_source IN (?)`, { replacements: [ sources ] });
}
if (ids.length) {
await sequelize.query('DELETE FROM `order_index` WHERE id IN (?)', { replacements: [ ids ] });
}
console.log(`[order] 已回退老数据搬迁:删除 ${ids.length} 条订单与对应明细`);
},
};
/**
* 查已搬迁订单的新 ID(按来源表 + 源主键)
* @param {Object} sequelize sequelize 实例
* @param {String} source 来源表
* @param {Number} legacyId 源主键
* @return {Promise<Number|null>} 新订单 ID
*/
async function findMigratedOrderId(sequelize, source, legacyId) {
for (const table of ALL_STATUS_TABLES) {
const [ rows ] = await sequelize.query(
`SELECT id FROM \`${table}\` WHERE legacy_source = ? AND legacy_order_id = ? LIMIT 1`,
{ replacements: [ source, legacyId ] }
);
if (rows.length) return rows[0].id;
}
return null;
}
/**
* 明细是否已搬迁
* @param {Object} sequelize sequelize 实例
* @param {String} source 来源表
* @param {Number} legacyId 源明细主键
* @return {Promise<Boolean>} 已存在返回 true
*/
async function itemExists(sequelize, source, legacyId) {
const [ rows ] = await sequelize.query(
'SELECT id FROM `order_status_items` WHERE legacy_source = ? AND legacy_order_item_id = ? LIMIT 1',
{ replacements: [ source, legacyId ] }
);
return rows.length > 0;
}