WMS_MAIN/app/model/order_items_factory.js
liufumingren 99367e5043 1
2026-06-06 05:15:46 +08:00

523 lines
16 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.

// order_items_factory.js
'use strict';
const {
ensureShardWarehouseId,
clearShardWarehouseValidationCache,
} = require('../lib/warehouse_shard_guard');
/**
* 克隆模型属性定义。
* @param {Object} attributes 属性定义。
* @return {Object} 克隆后的属性定义。
*/
function cloneAttributes(attributes) {
return Object.entries(attributes || {}).reduce((result, [ key, value ]) => {
result[key] = { ...value };
return result;
}, {});
}
/**
* 规范化索引定义。
* @param {Object} index 索引定义。
* @return {Object} 规范化后的索引定义。
*/
function normalizeIndexDefinition(index) {
let unique = false;
if (index && Object.prototype.hasOwnProperty.call(index, 'unique')) {
unique = Boolean(index.unique);
} else if (index && Object.prototype.hasOwnProperty.call(index, 'Unique')) {
unique = Boolean(index.Unique);
} else if (index && Object.prototype.hasOwnProperty.call(index, 'nonUnique')) {
unique = Number(index.nonUnique) === 0;
}
return {
name: index && (index.name || index.Key_name || index.key_name || index.index_name) || '',
unique,
fields: Array.isArray(index && index.fields)
? index.fields.map(field => {
if (typeof field === 'string') {
return {
attribute: field,
};
}
return {
attribute: field.attribute || field.name || field.field || field.columnName || '',
length: field.length,
};
})
: [],
};
}
/**
* 判断两个索引定义是否存在结构差异。
* @param {Object} expectedIndex 预期索引定义。
* @param {Object} actualIndex 实际索引定义。
* @return {boolean} 是否存在结构差异。
*/
function isIndexDefinitionDifferent(expectedIndex, actualIndex) {
const normalizedExpected = normalizeIndexDefinition(expectedIndex);
const normalizedActual = normalizeIndexDefinition(actualIndex);
if (!normalizedActual.name) {
return true;
}
if (normalizedExpected.unique !== normalizedActual.unique) {
return true;
}
if (normalizedExpected.fields.length !== normalizedActual.fields.length) {
return true;
}
for (let index = 0; index < normalizedExpected.fields.length; index += 1) {
const expectedField = normalizedExpected.fields[index];
const actualField = normalizedActual.fields[index];
if (!expectedField.attribute || !actualField.attribute) {
return true;
}
if (expectedField.attribute !== actualField.attribute) {
return true;
}
if (Object.prototype.hasOwnProperty.call(expectedField, 'length') && expectedField.length !== actualField.length) {
return true;
}
}
return false;
}
module.exports = app => {
const { Sequelize } = app;
class OrderItemsFactory {
constructor() {
this.modelCache = new Map();
this.app = app;
this.creatingTables = new Map(); // 防止并发创建表
}
/**
* 获取当前表模型
* @param {number} warehouseId 仓库ID
* @return {Promise<Object>} 当前表模型
*/
async getCurrentModel(warehouseId) {
return await this.getOrCreateModel(warehouseId, 'current');
}
/**
* 获取历史表模型
* @param {number} warehouseId 仓库ID
* @return {Promise<Object>} 历史表模型
*/
async getHistoryModel(warehouseId) {
return await this.getOrCreateModel(warehouseId, 'history');
}
/**
* 获取配送表模型。
* @param {number} warehouseId 仓库ID
* @return {Promise<Object>} 配送表模型
*/
async getDispatchModel(warehouseId) {
return await this.getOrCreateModel(warehouseId, 'dispatch');
}
/**
* 获取或创建模型
* @param {number} warehouseId 仓库ID
* @param {string} type 模型类型
* @return {Promise<Object>} 动态模型
*/
async getOrCreateModel(warehouseId, type = 'current') {
const warehouseIdStr = await ensureShardWarehouseId(this.app, warehouseId);
const cacheKey = `${warehouseIdStr}_${type}`;
// 检查缓存
if (this.modelCache.has(cacheKey)) {
return this.modelCache.get(cacheKey);
}
const tableName = this.generateTableName(warehouseIdStr, type);
try {
// 防止并发创建表
if (this.creatingTables.has(cacheKey)) {
await this.creatingTables.get(cacheKey);
return this.modelCache.get(cacheKey);
}
const createPromise = this.createModelWithRetry(warehouseIdStr, type, tableName, cacheKey);
this.creatingTables.set(cacheKey, createPromise);
const dynamicModel = await createPromise;
this.creatingTables.delete(cacheKey);
return dynamicModel;
} catch (error) {
this.creatingTables.delete(cacheKey);
this.app.logger.error(`获取订单商品模型失败 ${tableName}:`, error);
throw error;
}
}
/**
* 带重试的模型创建
* @param {number} warehouseId 仓库ID
* @param {string} type 模型类型
* @param {string} tableName 表名
* @param {string} cacheKey 缓存键
* @param {number} retryCount 重试次数
* @return {Promise<Object>} 动态模型
*/
async createModelWithRetry(warehouseId, type, tableName, cacheKey, retryCount = 3) {
for (let i = 0; i < retryCount; i++) {
try {
const DynamicModel = this.buildDynamicModel(warehouseId, type, tableName);
await this.ensureManagedTableSchema(tableName, type, warehouseId, DynamicModel);
// 复制关联关系
this.copyAssociations(this.app.model.OrderItems, DynamicModel);
// 缓存模型
this.modelCache.set(cacheKey, DynamicModel);
this.app.logger.info(`创建订单商品动态模型成功: ${tableName}`);
return DynamicModel;
} catch (error) {
if (i === retryCount - 1) {
throw error;
}
this.app.logger.warn(`创建模型失败,第${i + 1}次重试:`, error.message);
await this.sleep(500); // 等待500ms后重试
}
}
}
/**
* 复制关联关系
* @param {Object} sourceModel 源模型
* @param {Object} targetModel 目标模型
*/
copyAssociations(sourceModel, targetModel) {
if (sourceModel.associations) {
Object.keys(sourceModel.associations).forEach(key => {
const association = sourceModel.associations[key];
const options = { ...association.options };
// 避免动态表的外键约束问题
options.constraints = false;
if (association.associationType === 'BelongsTo') {
targetModel.belongsTo(
association.target,
{
...options,
foreignKey: association.foreignKey,
as: association.as,
}
);
}
});
}
}
/**
* 构建订单商品动态模型。
* @param {number|string} warehouseId 仓库ID。
* @param {string} type 模型类型。
* @param {string} tableName 表名。
* @return {Object} 动态模型。
*/
buildDynamicModel(warehouseId, type, tableName) {
const attributes = this.getTableAttributes(type);
const modelComment = type === 'history'
? `仓库${warehouseId}订单商品历史表`
: type === 'dispatch'
? `仓库${warehouseId}订单商品配送表`
: `仓库${warehouseId}订单商品常用表`;
return this.app.model.define(tableName, attributes, {
tableName,
timestamps: true,
underscored: true,
paranoid: false,
indexes: this.generateIndexes(warehouseId),
comment: modelComment,
});
}
/**
* 获取订单商品模型属性定义。
* @param {string} type 模型类型。
* @return {Object} 属性定义。
*/
getTableAttributes(type) {
const mainModel = this.app.model.OrderItems;
const attributes = cloneAttributes(mainModel && mainModel.rawAttributes);
// 保留 id 字段的 autoIncrement,与 order_delivery_factory 行为一致,
// 确保分表 wms_order_items_{warehouseId} 的 bulkCreate 能正常自增生成 id
if (type === 'history' && !attributes.archive_time) {
attributes.archive_time = {
type: this.app.Sequelize.DATE,
allowNull: true,
defaultValue: this.app.Sequelize.literal('CURRENT_TIMESTAMP'),
comment: '归档时间',
};
}
return attributes;
}
/**
* 生成索引配置
* @param {number} warehouseId 仓库ID
*/
generateIndexes(warehouseId) {
return [
{
name: `idx_${warehouseId}_order_id`,
fields: [ 'order_id' ],
},
{
name: `idx_${warehouseId}_item_id`,
fields: [ 'item_id' ],
},
{
name: `idx_${warehouseId}_item_code`,
fields: [ 'item_code' ],
},
{
name: `idx_${warehouseId}_source_order_code`,
fields: [ 'source_order_code' ],
},
{
name: `idx_${warehouseId}_stock_id`,
fields: [ 'stock_id' ],
},
{
name: `idx_${warehouseId}_owner_code`,
fields: [ 'owner_code' ],
},
{
name: `idx_${warehouseId}_order_item`,
fields: [ 'order_id', 'item_id' ],
},
{
name: `idx_${warehouseId}_created_at`,
fields: [ 'created_at' ],
},
];
}
/**
* 检查表是否存在
* @param {string} tableName 表名
*/
async checkTableExists(tableName) {
try {
const [ results ] = await this.app.model.query(
`SELECT 1 FROM information_schema.tables
WHERE table_schema = DATABASE()
AND table_name = :tableName`,
{
replacements: { tableName },
type: Sequelize.QueryTypes.SELECT,
}
);
return Array.isArray(results)
? results.length > 0
: Boolean(results);
} catch (error) {
this.app.logger.error('检查表是否存在失败:', error);
return false;
}
}
/**
* 判断目标表是否需要进行结构同步。
* @param {string} tableName 表名。
* @param {string} type 模型类型。
* @param {number|string} warehouseId 仓库ID。
* @param {boolean|null} [tableExists=null] 是否已确认表存在。
* @return {Promise<boolean>} 是否需要同步。
*/
async needsTableSchemaSync(tableName, type, warehouseId, tableExists = null) {
const queryInterface = this.app.model.getQueryInterface();
const managedTableExists = typeof tableExists === 'boolean'
? tableExists
: await this.checkTableExists(tableName);
if (!managedTableExists) {
return true;
}
const [ tables, indexes ] = await Promise.all([
queryInterface.describeTable(tableName),
typeof queryInterface.showIndex === 'function'
? queryInterface.showIndex(tableName)
: Promise.resolve([]),
]);
const expectedAttributes = this.getTableAttributes(type);
const expectedAttributeNames = Object.keys(expectedAttributes);
const actualAttributeNames = Object.keys(tables || {});
if (expectedAttributeNames.length !== actualAttributeNames.length) {
return true;
}
const actualColumnNames = new Set(actualAttributeNames);
for (const columnName of expectedAttributeNames) {
if (!actualColumnNames.has(columnName)) {
return true;
}
}
for (const columnName of expectedAttributeNames) {
const expectedColumn = expectedAttributes[columnName];
const actualColumn = tables[columnName] || {};
const expectedType = expectedColumn.type && typeof expectedColumn.type.toSql === 'function'
? expectedColumn.type.toSql().toLowerCase()
: String(expectedColumn.type || '').toLowerCase();
const actualType = String(actualColumn.type || actualColumn.Type || '').toLowerCase();
const expectedAllowNull = expectedColumn.allowNull !== false;
const actualAllowNull = actualColumn.allowNull !== false;
const expectedDefault = Object.prototype.hasOwnProperty.call(expectedColumn, 'defaultValue')
? expectedColumn.defaultValue
: undefined;
const actualDefault = Object.prototype.hasOwnProperty.call(actualColumn, 'defaultValue')
? actualColumn.defaultValue
: undefined;
if (expectedType && actualType && expectedType !== actualType) {
return true;
}
if (expectedAllowNull !== actualAllowNull) {
return true;
}
const normalizedExpectedDefault = expectedDefault == null ? null : String(expectedDefault);
const normalizedActualDefault = actualDefault == null ? null : String(actualDefault);
if (normalizedExpectedDefault !== normalizedActualDefault) {
return true;
}
}
const expectedIndexes = this.generateIndexes(warehouseId);
const actualIndexes = Array.isArray(indexes) ? indexes : [];
for (const expectedIndex of expectedIndexes) {
const actualIndex = actualIndexes.find(index => (index.Key_name || index.name) === expectedIndex.name);
if (!actualIndex) {
return true;
}
if (isIndexDefinitionDifferent(expectedIndex, actualIndex)) {
return true;
}
}
return false;
}
/**
* 确保目标表与模型结构一致。
* @param {string} tableName 表名。
* @param {string} type 模型类型。
* @param {number|string} warehouseId 仓库ID。
* @param {Object} [DynamicModel] 已构建的动态模型。
* @return {Promise<boolean>} 是否执行了同步。
*/
async ensureManagedTableSchema(tableName, type, warehouseId, DynamicModel = null) {
const dynamicModel = DynamicModel || this.buildDynamicModel(warehouseId, type, tableName);
const tableExists = await this.checkTableExists(tableName);
const needsSync = tableExists
? await this.needsTableSchemaSync(tableName, type, warehouseId, tableExists)
: true;
if (!needsSync) {
return false;
}
await dynamicModel.sync({ alter: true });
return true;
}
/**
* 创建物理表。
* @param {number} warehouseId 仓库ID
* @param {string} type 模型类型
*/
async createPhysicalTable(warehouseId, type = 'current') {
const tableName = this.generateTableName(warehouseId, type);
const dynamicModel = this.buildDynamicModel(warehouseId, type, tableName);
await dynamicModel.sync({ alter: true });
this.app.logger.info(`创建/同步订单商品物理表成功: ${tableName}`);
}
/**
* 生成表名
* @param {number} warehouseId 仓库ID
* @param {string} type 模型类型
*/
generateTableName(warehouseId, type) {
const suffix = type === 'history'
? '_history'
: type === 'dispatch'
? '_dispatch'
: '';
return `wms_order_items_${warehouseId}${suffix}`;
}
/**
* 清除缓存
* @param {number} warehouseId 仓库ID
* @param {string} type 模型类型
*/
clearCache(warehouseId, type) {
const cacheKey = `${warehouseId}_${type}`;
this.modelCache.delete(cacheKey);
this.creatingTables.delete(cacheKey);
clearShardWarehouseValidationCache(this.app);
}
/**
* 清除所有缓存
*/
clearAllCache() {
this.modelCache.clear();
this.creatingTables.clear();
clearShardWarehouseValidationCache(this.app);
}
/**
* 休眠函数
* @param {number} ms 毫秒数
*/
sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
return new OrderItemsFactory();
};