AiDOPWarehouse/server/Admin.NET.Core/SqlSugar/SqlSugarSetup.cs

// Admin.NET 项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE-MIT 和 LICENSE-APACHE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！

using System.Reflection;
using Microsoft.Data.Sqlite;
using DbType = SqlSugar.DbType;

namespace Admin.NET.Core;

public static class SqlSugarSetup
{
    // 多租户实例
    public static ITenant ITenant { get; set; }

    // 是否正在处理种子数据
    private static bool _isHandlingSeedData = false;

    /// <summary>
    /// SqlSugar 上下文初始化
    /// </summary>
    /// <param name="services"></param>
    public static void AddSqlSugar(this IServiceCollection services)
    {
        // 注册雪花Id
        var snowIdOpt = App.GetConfig<SnowIdOptions>("SnowId", true);
        YitIdHelper.SetIdGenerator(snowIdOpt);

        // 自定义 SqlSugar 雪花ID算法
        SnowFlakeSingle.WorkId = snowIdOpt.WorkerId;
        StaticConfig.CustomSnowFlakeFunc = YitIdHelper.NextId;
        // 注册 MongoDb
        InstanceFactory.CustomAssemblies = [typeof(SqlSugar.MongoDb.MongoDbProvider).Assembly];
        // 动态表达式 SqlFunc 支持，https://www.donet5.com/Home/Doc?typeId=2569
        StaticConfig.DynamicExpressionParserType = typeof(DynamicExpressionParser);
        StaticConfig.DynamicExpressionParsingConfig = new ParsingConfig
        {
            CustomTypeProvider = new SqlSugarTypeProvider()
        };

        var dbOptions = App.GetConfig<DbConnectionOptions>("DbConnection", true);
        // Docker 等对已有库部署：避免每次启动跑 CodeFirst/全量种子导致冲突（见 docker-compose 环境变量 DOCKER_SKIP_DBINIT）
        if (string.Equals(Environment.GetEnvironmentVariable("DOCKER_SKIP_DBINIT"), "1", StringComparison.Ordinal)
            && dbOptions.ConnectionConfigs != null)
        {
            foreach (var c in dbOptions.ConnectionConfigs)
            {
                if (c.DbSettings != null)
                {
                    c.DbSettings.EnableInitDb = false;
                    c.DbSettings.EnableInitView = false;
                }
                if (c.TableSettings != null)
                    c.TableSettings.EnableInitTable = false;
                if (c.SeedSettings != null)
                    c.SeedSettings.EnableInitSeed = false;
            }
        }
        dbOptions.ConnectionConfigs.ForEach(SetDbConfig);

        SqlSugarScope sqlSugar = new(dbOptions.ConnectionConfigs.Adapt<List<ConnectionConfig>>(), db =>
        {
            dbOptions.ConnectionConfigs.ForEach(config =>
            {
                var dbProvider = db.GetConnectionScope(config.ConfigId);
                SetDbAop(dbProvider, dbOptions.EnableConsoleSql, dbOptions.SuperAdminIgnoreIDeletedFilter);
                SetDbDiffLog(dbProvider, config);
            });
        });
        ITenant = sqlSugar;

        services.AddSingleton<ISqlSugarClient>(sqlSugar); // 单例注册
        services.AddScoped(typeof(SqlSugarRepository<>)); // 仓储注册
        services.AddUnitOfWork<SqlSugarUnitOfWork>(); // 事务与工作单元注册

        // 初始化数据库表结构及种子数据
        dbOptions.ConnectionConfigs.ForEach(config =>
        {
            InitDatabase(sqlSugar, config);
        });
    }

    /// <summary>
    /// 配置连接属性
    /// </summary>
    /// <param name="config"></param>
    public static void SetDbConfig(DbConnectionConfig config)
    {
        if (config.DbSettings.EnableConnStringEncrypt)
            config.ConnectionString = CryptogramUtil.Decrypt(config.ConnectionString);

        var configureExternalServices = new ConfigureExternalServices
        {
            EntityNameService = (type, entity) => // 处理表
            {
                entity.IsDisabledDelete = true; // 禁止删除非 sqlsugar 创建的列
                // 只处理贴了特性[SugarTable]表
                if (!type.GetCustomAttributes<SugarTable>().Any())
                    return;
                if (config.DbSettings.EnableUnderLine && !entity.DbTableName.Contains('_'))
                    entity.DbTableName = entity.DbTableName.ToUnderLine(); // 驼峰转下划线
            },
            EntityService = (type, column) => // 处理列
            {
                // 只处理贴了特性[SugarColumn]列
                if (!type.GetCustomAttributes<SugarColumn>().Any())
                    return;
                if (new NullabilityInfoContext().Create(type).WriteState is NullabilityState.Nullable)
                    column.IsNullable = true;
                if (config.DbSettings.EnableUnderLine && !column.IsIgnore && !column.DbColumnName.Contains('_'))
                {
                    // 遗留表 NbrControl：库中为 PascalCase 审计列。若再转下划线会变成 create_time 等，
                    // CodeFirst 会误判缺列并执行 ADD；在要求「不改表」的部署下应保持 Pascal 物理列名。
                    const string nbrControlTypeFullName = "Admin.NET.Plugin.AiDOP.Entity.S0.Warehouse.AdoS0NbrControl";
                    var skipUnderline = type is PropertyInfo pi
                        && string.Equals(pi.DeclaringType?.FullName, nbrControlTypeFullName, StringComparison.Ordinal)
                        && (pi.Name == "CreateTime" || pi.Name == "UpdateTime" || pi.Name == "CreateUser" || pi.Name == "UpdateUser");
                    if (!skipUnderline)
                        column.DbColumnName = column.DbColumnName.ToUnderLine();
                }
            },
            DataInfoCacheService = new SqlSugarCache(),
        };
        config.ConfigureExternalServices = configureExternalServices;
        config.InitKeyType = InitKeyType.Attribute;
        config.IsAutoCloseConnection = true;
        config.MoreSettings = new ConnMoreSettings
        {
            IsAutoRemoveDataCache = true, // 启用自动删除缓存，所有增删改会自动调用.RemoveDataCache()
            IsAutoDeleteQueryFilter = true, // 启用删除查询过滤器
            IsAutoUpdateQueryFilter = true, // 启用更新查询过滤器
            SqlServerCodeFirstNvarchar = true // 采用Nvarchar
        };

        // 若库类型是人大金仓则默认设置PG模式
        if (config.DbType == DbType.Kdbndp)
            config.MoreSettings.DatabaseModel = DbType.PostgreSQL; // 配置PG模式主要是兼容系统表差异

        // 若库类型是Oracle则默认主键名字和参数名字最大长度
        if (config.DbType == DbType.Oracle)
            config.MoreSettings.MaxParameterNameLength = 30;
    }

    /// <summary>
    /// 配置Aop
    /// </summary>
    /// <param name="db"></param>
    /// <param name="enableConsoleSql"></param>
    /// <param name="superAdminIgnoreIDeletedFilter"></param>
    public static void SetDbAop(SqlSugarScopeProvider db, bool enableConsoleSql, bool superAdminIgnoreIDeletedFilter)
    {
        // 设置超时时间
        db.Ado.CommandTimeOut = 30;

        // 打印SQL语句
        if (enableConsoleSql)
        {
            db.Aop.OnLogExecuting = (sql, pars) =>
            {
                //// 若参数值超过100个字符则进行截取
                //foreach (var par in pars)
                //{
                //    if (par.DbType != System.Data.DbType.String || par.Value == null) continue;
                //    if (par.Value.ToString().Length > 100)
                //        par.Value = string.Concat(par.Value.ToString()[..100], "......");
                //}

                var log = $"【{DateTime.Now}——执行SQL】\r\n{UtilMethods.GetNativeSql(sql, pars)}\r\n";
                var originColor = Console.ForegroundColor;
                if (sql.StartsWith("SELECT", StringComparison.OrdinalIgnoreCase))
                    Console.ForegroundColor = ConsoleColor.Green;
                if (sql.StartsWith("UPDATE", StringComparison.OrdinalIgnoreCase) || sql.StartsWith("INSERT", StringComparison.OrdinalIgnoreCase))
                    Console.ForegroundColor = ConsoleColor.Yellow;
                if (sql.StartsWith("DELETE", StringComparison.OrdinalIgnoreCase))
                    Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(log);
                Console.ForegroundColor = originColor;
            };
        }
        db.Aop.OnError = ex =>
        {
            if (ex.Parametres == null) return;
            var log = $"【{DateTime.Now}——错误SQL】\r\n{UtilMethods.GetNativeSql(ex.Sql, (SugarParameter[])ex.Parametres)}\r\n";
            Log.Error(log, ex);
        };
        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            //// 若参数值超过100个字符则进行截取
            //foreach (var par in pars)
            //{
            //    if (par.DbType != System.Data.DbType.String || par.Value == null) continue;
            //    if (par.Value.ToString().Length > 100)
            //        par.Value = string.Concat(par.Value.ToString()[..100], "......");
            //}

            // 执行时间超过5秒时
            if (!(db.Ado.SqlExecutionTime.TotalSeconds > 5)) return;

            var fileName = db.Ado.SqlStackTrace.FirstFileName; // 文件名
            var fileLine = db.Ado.SqlStackTrace.FirstLine; // 行号
            var firstMethodName = db.Ado.SqlStackTrace.FirstMethodName; // 方法名
            var log = $"【{DateTime.Now}——超时SQL】\r\n【所在文件名】：{fileName}\r\n【代码行数】：{fileLine}\r\n【方法名】：{firstMethodName}\r\n" + $"【SQL语句】：{UtilMethods.GetNativeSql(sql, pars)}";
            Log.Warning(log);
        };

        // 数据审计
        db.Aop.DataExecuting = (_, entityInfo) =>
        {
            // 若正在处理种子数据则直接返回
            if (_isHandlingSeedData) return;

            // 新增/插入
            if (entityInfo.OperationType == DataFilterType.InsertByObject)
            {
                // 若主键是长整型且空则赋值雪花Id
                if (entityInfo.EntityColumnInfo.IsPrimarykey && !entityInfo.EntityColumnInfo.IsIdentity && entityInfo.EntityColumnInfo.PropertyInfo.PropertyType == typeof(long))
                {
                    var id = entityInfo.EntityColumnInfo.PropertyInfo.GetValue(entityInfo.EntityValue);
                    if (id == null || (long)id == 0)
                        entityInfo.SetValue(YitIdHelper.NextId());
                }
                // 若创建时间为空则赋值当前时间
                else if (entityInfo.PropertyName == nameof(EntityBase.CreateTime))
                {
                    var createTime = entityInfo.EntityColumnInfo.PropertyInfo.GetValue(entityInfo.EntityValue)!;
                    if (createTime == null || createTime.Equals(DateTime.MinValue))
                        entityInfo.SetValue(DateTime.Now);
                }
                // 若当前用户为空（非web线程时）
                if (App.User == null) return;

                dynamic entityValue = entityInfo.EntityValue;
                if (entityInfo.PropertyName == nameof(EntityBaseTenantId.TenantId))
                {
                    var tenantId = entityValue.TenantId;
                    if (tenantId == null || tenantId == 0)
                        entityInfo.SetValue(App.User.FindFirst(ClaimConst.TenantId)?.Value);
                }
                else if (entityInfo.PropertyName == nameof(EntityBase.CreateUserId))
                {
                    var createUserId = entityValue.CreateUserId;
                    if (createUserId == 0 || createUserId == null)
                        entityInfo.SetValue(App.User.FindFirst(ClaimConst.UserId)?.Value);
                }
                else if (entityInfo.PropertyName == nameof(EntityBase.CreateUserName))
                {
                    var createUserName = entityValue.CreateUserName;
                    if (string.IsNullOrEmpty(createUserName))
                        entityInfo.SetValue(App.User.FindFirst(ClaimConst.RealName)?.Value);
                }
                else if (entityInfo.PropertyName == "CreateOrgId")
                {
                    var createOrgId = entityValue.CreateOrgId;
                    if (createOrgId == 0 || createOrgId == null)
                        entityInfo.SetValue(App.User.FindFirst(ClaimConst.OrgId)?.Value);
                }
                else if (entityInfo.PropertyName == "CreateOrgName")
                {
                    var createOrgName = entityValue.CreateOrgName;
                    if (string.IsNullOrEmpty(createOrgName))
                        entityInfo.SetValue(App.User.FindFirst(ClaimConst.OrgName)?.Value);
                }
            }
            // 编辑/更新
            else if (entityInfo.OperationType == DataFilterType.UpdateByObject
                     || entityInfo.OperationType == DataFilterType.DeleteByObject)
            {
                MdmMirrorWriteScope.RejectPageWrite(entityInfo.EntityValue);
                if (entityInfo.OperationType == DataFilterType.DeleteByObject)
                    return;
                if (entityInfo.PropertyName == nameof(EntityBase.UpdateTime))
                    entityInfo.SetValue(DateTime.Now);
                else if (entityInfo.PropertyName == nameof(EntityBaseDel.DeleteTime))
                {
                    dynamic entityValue = entityInfo.EntityValue;
                    var isDelete = entityValue.IsDelete;
                    if (isDelete == true)
                    {
                        entityInfo.SetValue(DateTime.Now);
                    }
                }
                // 若当前用户为空（非web线程时）
                if (App.User == null) return;

                if (entityInfo.PropertyName == nameof(EntityBase.UpdateUserId))
                    entityInfo.SetValue(App.User?.FindFirst(ClaimConst.UserId)?.Value);
                else if (entityInfo.PropertyName == nameof(EntityBase.UpdateUserName))
                    entityInfo.SetValue(App.User?.FindFirst(ClaimConst.RealName)?.Value);
            }
        };

        // 是否为超级管理员
        var isSuperAdmin = App.User?.FindFirst(ClaimConst.AccountType)?.Value == ((int)AccountTypeEnum.SuperAdmin).ToString();

        // 配置假删除过滤器，如果当前用户是超级管理员并且允许忽略软删除过滤器则不会应用
        if (!isSuperAdmin || !superAdminIgnoreIDeletedFilter)
            db.QueryFilter.AddTableFilter<IDeletedFilter>(u => u.IsDelete == false);

        // 超管排除其他过滤器
        if (isSuperAdmin) return;

        // 配置租户过滤器
        var tenantId = App.User?.FindFirst(ClaimConst.TenantId)?.Value;
        if (!string.IsNullOrWhiteSpace(tenantId))
            db.QueryFilter.AddTableFilter<ITenantIdFilter>(u => u.TenantId == long.Parse(tenantId));

        // 配置用户机构（数据范围）过滤器
        SqlSugarFilter.SetOrgEntityFilter(db);

        // 配置自定义过滤器
        SqlSugarFilter.SetCustomEntityFilter(db);
    }

    /// <summary>
    /// 开启库表差异化日志
    /// </summary>
    /// <param name="db"></param>
    /// <param name="config"></param>
    private static void SetDbDiffLog(SqlSugarScopeProvider db, DbConnectionConfig config)
    {
        if (!config.DbSettings.EnableDiffLog) return;

        async void AopOnDiffLogEvent(DiffLogModel u)
        {
            // 记录差异数据
            var diffData = new List<dynamic>();
            for (int i = 0; i < u.AfterData.Count; i++)
            {
                var diffColumns = new List<dynamic>();
                var afterColumns = u.AfterData[i].Columns;
                var beforeColumns = u.BeforeData[i].Columns;
                for (int j = 0; j < afterColumns.Count; j++)
                {
                    if (afterColumns[j].Value.Equals(beforeColumns[j].Value)) continue;
                    diffColumns.Add(new
                    {
                        afterColumns[j].IsPrimaryKey,
                        afterColumns[j].ColumnName,
                        afterColumns[j].ColumnDescription,
                        BeforeValue = beforeColumns[j].Value,
                        AfterValue = afterColumns[j].Value,
                    });
                }

                diffData.Add(new { u.AfterData[i].TableName, u.AfterData[i].TableDescription, Columns = diffColumns });
            }

            var logDiff = new SysLogDiff
            {
                // 差异数据（字段描述、列名、值、表名、表描述）
                DiffData = JSON.Serialize(diffData),
                // 传进来的对象（如果对象为空，则使用首个数据的表名作为业务对象）
                BusinessData = u.BusinessData == null ? u.AfterData.FirstOrDefault()?.TableName : JSON.Serialize(u.BusinessData),
                // 枚举（insert、update、delete）
                DiffType = u.DiffType.ToString(),
                Sql = u.Sql,
                Parameters = JSON.Serialize(u.Parameters.Select(e => new { e.ParameterName, e.Value, TypeName = e.DbType.ToString() })),
                Elapsed = u.Time == null ? 0 : (long)u.Time.Value.TotalMilliseconds
            };
            var logDb = ITenant.IsAnyConnection(SqlSugarConst.LogConfigId) ? ITenant.GetConnectionScope(SqlSugarConst.LogConfigId) : ITenant.GetConnectionScope(SqlSugarConst.MainConfigId);
            await logDb.CopyNew().Insertable(logDiff).ExecuteCommandAsync();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(DateTime.Now + $"\r\n*****开始差异日志*****\r\n{Environment.NewLine}{JSON.Serialize(logDiff)}{Environment.NewLine}*****结束差异日志*****\r\n");
        }

        db.Aop.OnDiffLogEvent = AopOnDiffLogEvent;
    }

    /// <summary>
    /// 初始化视图
    /// </summary>
    /// <param name="dbProvider"></param>
    private static void InitView(SqlSugarScopeProvider dbProvider)
    {
        var totalWatch = Stopwatch.StartNew(); // 开始总计时
        Log.Information($"初始化视图 {dbProvider.CurrentConnectionConfig.DbType} - {dbProvider.CurrentConnectionConfig.ConfigId}");
        var viewTypeList = App.EffectiveTypes.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.GetInterfaces().Any(i => i.HasImplementedRawGeneric(typeof(ISqlSugarView)))).ToList();

        int taskIndex = 0, size = viewTypeList.Count;
        var taskList = viewTypeList.Select(viewType => Task.Run(() =>
        {
            try
            {
                // 开始计时
                var stopWatch = Stopwatch.StartNew();

                // 获取视图实体和配置信息
                var entityInfo = dbProvider.EntityMaintenance.GetEntityInfo(viewType) ?? throw new Exception("获取视图实体配置有误");

                // 如果视图存在，则删除视图
                if (dbProvider.DbMaintenance.GetViewInfoList(false).Any(it => it.Name.EqualIgnoreCase(entityInfo.DbTableName)))
                {
                    try
                    {
                        dbProvider.DbMaintenance.DropView(entityInfo.DbTableName);
                    }
                    catch (Exception dropEx)
                    {
                        Log.Warning($"删除视图失败（可能无权限），跳过：{entityInfo.DbTableName} — {dropEx.Message}");
                    }
                }

                // 获取初始化视图查询SQL
                var sql = viewType.GetMethod(nameof(ISqlSugarView.GetQueryableSqlString))?.Invoke(Activator.CreateInstance(viewType), [dbProvider]) as string;
                if (string.IsNullOrWhiteSpace(sql)) throw new Exception("视图初始化Sql语句不能为空");

                // 创建视图
                dbProvider.Ado.ExecuteCommand($"CREATE VIEW {entityInfo.DbTableName} AS " + Environment.NewLine + " " + sql);

                // 停止计时
                stopWatch.Stop();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"初始化视图 {viewType.FullName,-58} ({dbProvider.CurrentConnectionConfig.ConfigId} - {Interlocked.Increment(ref taskIndex):D003}/{size:D003}，耗时：{stopWatch.ElapsedMilliseconds:N0} ms)");
            }
            catch (Exception ex)
            {
                Log.Warning($"初始化视图失败已跳过：{viewType.FullName} — {ex.Message}");
            }
        }));
        Task.WaitAll(taskList.ToArray());

        totalWatch.Stop(); // 停止总计时
        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine($"初始化视图 {dbProvider.CurrentConnectionConfig.DbType} - {dbProvider.CurrentConnectionConfig.ConfigId} 总耗时：{totalWatch.ElapsedMilliseconds:N0} ms");
    }

    /// <summary>
    /// 等待数据库就绪
    /// </summary>
    /// <param name="dbProvider"></param>
    private static void WaitForDatabaseReady(SqlSugarScopeProvider dbProvider)
    {
        var maxWaitSeconds = 0;
        _ = int.TryParse(Environment.GetEnvironmentVariable("AIDOP_DB_WAIT_MAX_SECONDS"), out maxWaitSeconds);
        var deadline = maxWaitSeconds > 0 ? DateTime.UtcNow.AddSeconds(maxWaitSeconds) : DateTime.MaxValue;

        do
        {
            if (maxWaitSeconds > 0 && DateTime.UtcNow > deadline)
            {
                throw new TimeoutException(
                    $"等待数据库就绪已超过 {maxWaitSeconds} 秒（环境变量 AIDOP_DB_WAIT_MAX_SECONDS）。请检查连接串、网络与账号权限；不需要超时限制时请移除此环境变量。");
            }

            try
            {
                if (dbProvider.Ado.Connection.State != ConnectionState.Open)
                    dbProvider.Ado.Connection.Open();

                // 如果连接成功，直接返回
                Log.Information("数据库连接成功。");
                return;
            }
            catch (Exception ex)
            {
                Log.Warning($"数据库尚未就绪，等待中... 错误：{ex.Message}");
                Thread.Sleep(1000);
            }
        } while (true);
    }

    /// <summary>
    /// 初始化数据库
    /// </summary>
    /// <param name="db">SqlSugarScope 实例</param>
    /// <param name="config">数据库连接配置</param>
    private static void InitDatabase(SqlSugarScope db, DbConnectionConfig config)
    {
        var dbProvider = db.GetConnectionScope(config.ConfigId);

        // 初始化数据库  如果是没有数据库的话，是先初始化数据库再做连接
        if (config.DbSettings.EnableInitDb)
        {
            Log.Information($"初始化数据库 {config.DbType} - {config.ConfigId} - {config.ConnectionString}");
            if (config.DbType != DbType.Oracle) dbProvider.DbMaintenance.CreateDatabase();
        }

        // 等待数据库连接就绪
        WaitForDatabaseReady(dbProvider);

        // 初始化表结构
        if (config.TableSettings.EnableInitTable)
        {
            Log.Information($"初始化表结构 {config.DbType} - {config.ConfigId}");
            var entityTypes = GetEntityTypesForInit(config);
            var originCommandTimeout = dbProvider.Ado.CommandTimeOut;
            dbProvider.Ado.CommandTimeOut = ResolveInitTableCommandTimeout(config);
            try
            {
                RunPreInitMigrations(dbProvider, entityTypes);
                InitializeTables(dbProvider, entityTypes, config);
            }
            finally
            {
                dbProvider.Ado.CommandTimeOut = originCommandTimeout;
            }
        }

        // 初始化视图
        if (config.DbSettings.EnableInitView) InitView(dbProvider);

        // 初始化种子数据
        if (config.SeedSettings.EnableInitSeed) InitSeedData(db, config);
    }

    /// <summary>
    /// 获取需要初始化的实体类型
    /// </summary>
    /// <param name="config">数据库连接配置</param>
    /// <returns>实体类型列表</returns>
    private static List<Type> GetEntityTypesForInit(DbConnectionConfig config)
    {
        return App.EffectiveTypes
            .Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.IsDefined(typeof(SugarTable), false))
            .Where(u => !u.GetCustomAttributes<IgnoreTableAttribute>().Any())
            .WhereIF(config.TableSettings.EnableIncreTable, u => u.IsDefined(typeof(IncreTableAttribute), false))
            .Where(u => IsEntityForConfig(u, config))
            .ToList();
    }

    /// <summary>
    /// 在全局 InitTables 之前执行插件级预迁移，避免 CodeFirst 先补出新列。
    /// </summary>
    private static void RunPreInitMigrations(SqlSugarScopeProvider dbProvider, List<Type> entityTypes)
    {
        if (!entityTypes.Any(t => t.FullName?.Contains(".Entity.S0.") == true))
            return;

        var migrationType = App.EffectiveTypes.FirstOrDefault(t =>
            t.FullName == "Admin.NET.Plugin.AiDOP.Infrastructure.AidopS0ExcelColumnMigration");
        var migrateMethod = migrationType?.GetMethod("Migrate", BindingFlags.Public | BindingFlags.Static);
        if (migrateMethod == null)
            return;

        try
        {
            migrateMethod.Invoke(null, [dbProvider]);
        }
        catch (TargetInvocationException tie) when (tie.InnerException != null)
        {
            Log.Error($"AidopS0ExcelColumnMigration.Migrate 执行失败：{tie.InnerException.Message}", tie.InnerException);
            throw tie.InnerException;
        }
    }

    /// <summary>
    /// 判断实体是否属于当前配置
    /// </summary>
    /// <param name="entityType">实体类型</param>
    /// <param name="config">数据库连接配置</param>
    /// <returns>是否属于当前配置</returns>
    private static bool IsEntityForConfig(Type entityType, DbConnectionConfig config)
    {
        switch (config.ConfigId.ToString())
        {
            case SqlSugarConst.MainConfigId:
                return entityType.GetCustomAttributes<SysTableAttribute>().Any() ||
                       (!entityType.GetCustomAttributes<LogTableAttribute>().Any() &&
                        !entityType.GetCustomAttributes<TenantAttribute>().Any(o => o.configId.ToString() != config.ConfigId.ToString()));

            case SqlSugarConst.LogConfigId:
                return entityType.GetCustomAttributes<LogTableAttribute>().Any();

            default:
                {
                    var tenantAttribute = entityType.GetCustomAttribute<TenantAttribute>();
                    return tenantAttribute != null && tenantAttribute.configId.ToString() == config.ConfigId.ToString();
                }
        }
    }

    /// <summary>
    /// 初始化表结构
    /// </summary>
    /// <param name="dbProvider">SqlSugarScopeProvider 实例</param>
    /// <param name="entityTypes">实体类型列表</param>
    /// <param name="config">数据库连接配置</param>
    private static void InitializeTables(SqlSugarScopeProvider dbProvider, List<Type> entityTypes, DbConnectionConfig config)
    {
        // 删除视图再初始化表结构，防止因为视图导致无法同步表结构
        var viewTypeList = App.EffectiveTypes.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.GetInterfaces().Any(i => i.HasImplementedRawGeneric(typeof(ISqlSugarView)))).ToList();
        foreach (var viewType in viewTypeList)
        {
            var entityInfo = dbProvider.EntityMaintenance.GetEntityInfo(viewType) ?? throw new Exception("获取视图实体配置有误");
            if (dbProvider.DbMaintenance.GetViewInfoList(false).Any(it => it.Name.EqualIgnoreCase(entityInfo.DbTableName)))
            {
                try
                {
                    dbProvider.DbMaintenance.DropView(entityInfo.DbTableName);
                }
                catch (Exception ex)
                {
                    // 低权限账号下可能不具备 DROP VIEW 权限，跳过视图删除避免启动中断
                    Console.WriteLine($"跳过删除视图 {entityInfo.DbTableName}：{ex.Message}");
                }
            }
        }

        var maxDegree = ResolveInitTableMaxDegreeOfParallelism(config);
        int count = 0, sum = entityTypes.Count;

        var continueOnEntityFailure = ResolveContinueInitTableOnEntityFailure(config);

        void InitOne(Type entityType)
        {
            var label = entityType.FullName ?? entityType.Name;
            string tableName = "";
            try
            {
                tableName = dbProvider.EntityMaintenance.GetEntityInfo(entityType).DbTableName;
            }
            catch
            {
                // 仅用于日志；后续 UpdateNullableColumns 仍会抛出更具体错误
            }

            Console.WriteLine($"初始化表结构 {entityType.FullName,-64} ({config.ConfigId} - {Interlocked.Increment(ref count):D003}/{sum:D003})");
            try
            {
                UpdateNullableColumns(dbProvider, entityType);
                InitializeTable(dbProvider, entityType, config);
            }
            catch (Exception ex)
            {
                // MySQL 上部分 DDL 具备幂等语义，但不同版本/元数据读取差异可能导致 CodeFirst 重复生成 DDL。
                // 典型：表已有主键时仍尝试 ADD PRIMARY KEY -> Multiple primary key defined。
                // 这类问题不应阻塞启动与其余实体初始化（联调环境更常见）。
                var msg = ex.ToString();
                if (msg.Contains("Multiple primary key defined", StringComparison.OrdinalIgnoreCase)
                    || msg.Contains("Duplicate key name", StringComparison.OrdinalIgnoreCase)
                    || msg.Contains("Duplicate column name", StringComparison.OrdinalIgnoreCase)
                    || msg.Contains("All parts of a PRIMARY KEY must be NOT NULL", StringComparison.OrdinalIgnoreCase)
                    || msg.Contains("Can't DROP", StringComparison.OrdinalIgnoreCase) && msg.Contains("check that column/key exists", StringComparison.OrdinalIgnoreCase))
                {
                    Log.Warning($"初始化表结构遇到可忽略的 DDL 冲突，已跳过：Entity={label} Table={tableName} ConfigId={config.ConfigId} — {ex.Message}");
                    return;
                }

                Log.Error($"初始化表结构失败 Entity={label} Table={tableName} ConfigId={config.ConfigId}: {ex.Message}", ex);
                if (continueOnEntityFailure)
                {
                    Log.Warning(
                        "已启用跳过单表失败（TableSettings:ContinueInitTableOnEntityFailure 或环境变量 AIDOP_CODEFIRST_CONTINUE_ON_ENTITY_ERROR=1），将继续初始化其余实体；库结构可能不完整。");
                    return;
                }

                throw new InvalidOperationException(
                    $"表结构初始化失败: {label}（表 {tableName}）。请检查上方日志中的 DDL/SQL 异常；可临时关闭 TableSettings:EnableInitTable，或仅在联调时开启 ContinueInitTableOnEntityFailure / AIDOP_CODEFIRST_CONTINUE_ON_ENTITY_ERROR=1。",
                    ex);
            }
        }

        if (maxDegree <= 1)
        {
            foreach (var entityType in entityTypes)
                InitOne(entityType);
            return;
        }

        Parallel.ForEach(entityTypes, new ParallelOptions { MaxDegreeOfParallelism = maxDegree }, InitOne);
    }

    /// <summary>
    /// 更新表中不存在于实体的字段为可空
    /// </summary>
    /// <param name="dbProvider">SqlSugarScopeProvider 实例</param>
    /// <param name="entityType">实体类型</param>
    private static void UpdateNullableColumns(SqlSugarScopeProvider dbProvider, Type entityType)
    {
        var entityInfo = dbProvider.EntityMaintenance.GetEntityInfo(entityType);
        var dbColumns = dbProvider.DbMaintenance.GetColumnInfosByTableName(entityInfo.DbTableName) ?? new List<DbColumnInfo>();

        foreach (var dbColumn in dbColumns.Where(c => !c.IsPrimarykey && entityInfo.Columns.All(u => u.DbColumnName != c.DbColumnName)))
        {
            try
            {
                dbColumn.IsNullable = true;
                Retry(() =>
                {
                    dbProvider.DbMaintenance.UpdateColumn(entityInfo.DbTableName, dbColumn);
                }, maxRetry: 3, retryIntervalMs: 1000);
            }
            catch (Exception ex)
            {
                // 低权限或列类型不支持等：不应阻塞整张表 CodeFirst
                Log.Warning($"将多余列改为可空失败，已跳过：{entityInfo.DbTableName}.{dbColumn.DbColumnName} — {ex.Message}");
            }
        }
    }

    /// <summary>
    /// 初始化表
    /// </summary>
    /// <param name="dbProvider">SqlSugarScopeProvider 实例</param>
    /// <param name="entityType">实体类型</param>
    private static void InitializeTable(SqlSugarScopeProvider dbProvider, Type entityType, DbConnectionConfig config)
    {
        Retry(() =>
        {
            if (entityType.GetCustomAttribute<SplitTableAttribute>() == null)
            {
                dbProvider.CodeFirst.InitTables(entityType);
            }
            else
            {
                dbProvider.CodeFirst.SplitTables().InitTables(entityType);
            }
        }, ResolveInitTableRetryCount(config), ResolveInitTableRetryIntervalMs(config));
    }

    /// <summary>
    /// 初始化种子数据
    /// </summary>
    /// <param name="db">SqlSugarScope 实例</param>
    /// <param name="config">数据库连接配置</param>
    private static void InitSeedData(SqlSugarScope db, DbConnectionConfig config)
    {
        _isHandlingSeedData = true;
        try
        {
            Log.Information($"初始化种子数据 {config.DbType} - {config.ConfigId}");
            var seedDataTypes = GetSeedDataTypes(config);

            int count = 0, sum = seedDataTypes.Count;
            foreach (var seedType in seedDataTypes)
            {
                var entityType = seedType.GetInterfaces().First().GetGenericArguments().First();
                if (!IsEntityForConfig(entityType, config)) continue;

                var seedData = GetSeedData(seedType)?.ToList();
                if (seedData == null) continue;

                AdjustSeedDataIds(seedData, config);
                try
                {
                    var dbProvider = db.GetConnectionScope(config.ConfigId);
                    InsertOrUpdateSeedData(dbProvider, seedType, entityType, seedData, config, ref count, sum);
                }
                catch (Exception ex)
                {
                    throw Oops.Oh($"初始化种子数据失败: Seed={seedType.FullName}, Entity={entityType.FullName}, ConfigId={config.ConfigId}", ex);
                }
            }
        }
        finally
        {
            _isHandlingSeedData = false;
        }
    }

    /// <summary>
    /// 获取种子数据类型
    /// </summary>
    /// <param name="config">数据库连接配置</param>
    /// <returns>种子数据类型列表</returns>
    private static List<Type> GetSeedDataTypes(DbConnectionConfig config)
    {
        return App.EffectiveTypes
            .Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.GetInterfaces().Any(i => i.HasImplementedRawGeneric(typeof(ISqlSugarEntitySeedData<>))))
            .WhereIF(config.SeedSettings.EnableIncreSeed, u => u.IsDefined(typeof(IncreSeedAttribute), false))
            .OrderBy(u => u.GetCustomAttributes(typeof(SeedDataAttribute), false).Length > 0 ? ((SeedDataAttribute)u.GetCustomAttributes(typeof(SeedDataAttribute), false)[0]).Order : 0)
            .ToList();
    }

    /// <summary>
    /// 获取种子数据
    /// </summary>
    /// <param name="seedType">种子数据类型</param>
    /// <returns>种子数据列表</returns>
    private static IEnumerable<object> GetSeedData(Type seedType)
    {
        var instance = Activator.CreateInstance(seedType);
        var hasDataMethod = seedType.GetMethod("HasData");
        return ((IEnumerable)hasDataMethod?.Invoke(instance, null))?.Cast<object>();
    }

    /// <summary>
    /// 调整种子数据的 ID
    /// </summary>
    /// <param name="seedData">种子数据列表</param>
    /// <param name="config">数据库连接配置</param>
    private static void AdjustSeedDataIds(IEnumerable<object> seedData, DbConnectionConfig config)
    {
        var seedId = config.ConfigId.ToLong();
        foreach (var data in seedData)
        {
            var idProperty = data.GetType().GetProperty(nameof(EntityBaseId.Id));
            if (idProperty == null || idProperty.PropertyType != typeof(Int64)) continue;

            var idValue = idProperty.GetValue(data);
            if (idValue == null || idValue.ToString() == "0" || string.IsNullOrWhiteSpace(idValue.ToString()))
            {
                idProperty.SetValue(data, ++seedId);
            }
        }
    }

    /// <summary>
    /// 插入或更新种子数据
    /// </summary>
    /// <param name="dbProvider">SqlSugarScopeProvider 实例</param>
    /// <param name="seedType">种子数据类型</param>
    /// <param name="entityType">实体类型</param>
    /// <param name="seedData">种子数据列表</param>
    /// <param name="config">数据库连接配置</param>
    /// <param name="count">当前处理的数量</param>
    /// <param name="sum">总数量</param>
    private static void InsertOrUpdateSeedData(SqlSugarScopeProvider dbProvider, Type seedType, Type entityType, IEnumerable<object> seedData, DbConnectionConfig config, ref int count, int sum)
    {
        var entityInfo = dbProvider.EntityMaintenance.GetEntityInfo(entityType);
        var dataList = seedData.ToList();

        if (entityType.GetCustomAttribute<SplitTableAttribute>(true) != null)
        {
            var initMethod = seedType.GetMethod("Init");
            initMethod?.Invoke(Activator.CreateInstance(seedType), new object[] { dbProvider });
        }
        else
        {
            int updateCount = 0, insertCount = 0;
            if (entityInfo.Columns.Any(u => u.IsPrimarykey))
            {
                var storage = dbProvider.StorageableByObject(dataList).ToStorage();
                if (seedType.GetCustomAttribute<IgnoreUpdateSeedAttribute>() == null)
                {
                    updateCount = storage.AsUpdateable
                        .IgnoreColumns(entityInfo.Columns
                            .Where(u => u.PropertyInfo.GetCustomAttribute<IgnoreUpdateSeedColumnAttribute>() != null)
                            .Select(u => u.PropertyName).ToArray())
                        .ExecuteCommand();
                }
                insertCount = storage.AsInsertable.ExecuteCommand();
            }
            else
            {
                if (!dbProvider.Queryable(entityInfo.DbTableName, entityInfo.DbTableName).Any())
                {
                    insertCount = dataList.Count;
                    dbProvider.InsertableByObject(dataList).ExecuteCommand();
                }
            }
            Console.WriteLine($"添加数据 {entityInfo.DbTableName,-32} ({config.ConfigId} - {Interlocked.Increment(ref count):D003}/{sum:D003}，数据量：{dataList.Count:D003}，插入 {insertCount:D003} 条记录，修改 {updateCount:D003} 条记录)");
        }
    }

    /// <summary>
    /// 初始化租户业务数据库
    /// </summary>
    /// <param name="iTenant"></param>
    /// <param name="config"></param>
    public static void InitTenantDatabase(ITenant iTenant, DbConnectionConfig config)
    {
        SetDbConfig(config);

        if (!iTenant.IsAnyConnection(config.ConfigId.ToString()))
            iTenant.AddConnection(config);
        var db = iTenant.GetConnectionScope(config.ConfigId.ToString());
        db.DbMaintenance.CreateDatabase();

        // 获取所有业务表-初始化租户库表结构（排除系统表、日志表、特定库表）
        var entityTypes = App.EffectiveTypes
            .Where(u => !u.GetCustomAttributes<IgnoreTableAttribute>().Any())
            .Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.IsDefined(typeof(SugarTable), false) &&
            !u.IsDefined(typeof(SysTableAttribute), false) && !u.IsDefined(typeof(LogTableAttribute), false) && !u.IsDefined(typeof(TenantAttribute), false)).ToList();
        if (entityTypes.Count == 0) return;

        foreach (var entityType in entityTypes)
        {
            var splitTable = entityType.GetCustomAttribute<SplitTableAttribute>();
            if (splitTable == null)
                db.CodeFirst.InitTables(entityType);
            else
                db.CodeFirst.SplitTables().InitTables(entityType);
        }
    }

    /// <summary>
    /// 简单的重试机制
    /// </summary>
    /// <param name="action"></param>
    /// <param name="maxRetry"></param>
    /// <param name="retryIntervalMs"></param>
    private static void Retry(Action action, int maxRetry, int retryIntervalMs)
    {
        int attempt = 0;
        while (true)
        {
            try
            {
                action();
                return;
            }
            catch (Exception ex) when (IsRetryableDatabaseInitException(ex))
            {
                if (++attempt >= maxRetry)
                {
                    Log.Error($"简单的重试机制:{ex.Message}"); throw;
                }
                Log.Information($"数据库初始化异常，正在重试... (尝试 {attempt}/{maxRetry}) {ex.Message}");
                Thread.Sleep(retryIntervalMs);
            }
        }
    }

    private static int ResolveInitTableMaxDegreeOfParallelism(DbConnectionConfig config)
    {
        var value = config.TableSettings?.InitTableMaxDegreeOfParallelism ?? 1;
        return value <= 0 ? 1 : value;
    }

    private static int ResolveInitTableRetryCount(DbConnectionConfig config)
    {
        var value = config.TableSettings?.InitTableRetryCount ?? 3;
        return value <= 0 ? 1 : value;
    }

    private static int ResolveInitTableRetryIntervalMs(DbConnectionConfig config)
    {
        var value = config.TableSettings?.InitTableRetryIntervalMs ?? 2000;
        return value < 0 ? 2000 : value;
    }

    private static int ResolveInitTableCommandTimeout(DbConnectionConfig config)
    {
        var value = config.TableSettings?.InitTableCommandTimeoutSeconds ?? 120;
        return value <= 0 ? 120 : value;
    }

    /// <summary>
    /// 单实体 CodeFirst 失败时是否跳过并继续（环境变量优先）。
    /// </summary>
    private static bool ResolveContinueInitTableOnEntityFailure(DbConnectionConfig config)
    {
        if (string.Equals(Environment.GetEnvironmentVariable("AIDOP_CODEFIRST_CONTINUE_ON_ENTITY_ERROR"), "1", StringComparison.OrdinalIgnoreCase))
            return true;
        return config.TableSettings?.ContinueInitTableOnEntityFailure == true;
    }

    private static bool IsRetryableDatabaseInitException(Exception ex)
    {
        if (ex is SqliteException sqliteException && sqliteException.SqliteErrorCode == 5)
            return true;

        var current = ex;
        while (current != null)
        {
            if (current is TimeoutException)
                return true;

            var typeName = current.GetType().FullName ?? "";
            var message = current.Message ?? "";
            if (typeName.Contains("SqlSugarException", StringComparison.OrdinalIgnoreCase) &&
                ContainsRetryableDatabaseMessage(message))
                return true;
            if (typeName.Contains("MySql", StringComparison.OrdinalIgnoreCase) &&
                ContainsRetryableDatabaseMessage(message))
                return true;
            if (ContainsRetryableDatabaseMessage(message))
                return true;

            current = current.InnerException;
        }

        return false;
    }

    private static bool ContainsRetryableDatabaseMessage(string message)
    {
        return message.Contains("timeout", StringComparison.OrdinalIgnoreCase)
               || message.Contains("timed out", StringComparison.OrdinalIgnoreCase)
               || message.Contains("Lock wait timeout", StringComparison.OrdinalIgnoreCase)
               || message.Contains("Deadlock found", StringComparison.OrdinalIgnoreCase)
               || message.Contains("database is locked", StringComparison.OrdinalIgnoreCase)
               || message.Contains("SQLITE_BUSY", StringComparison.OrdinalIgnoreCase);
    }
}