第2章 持久化初始数据到指定表

 004 AuthorityScopeEnum、Role、Topic、TaskInfoDto、TasksQz

       AuthorityScopeEnum：该枚举定义了6种当前程序的访问权限，前程序通过该枚举实例选定其中(NONE(-1：无任何权限)/Custom(1：自定义权限)/MyDepart(2：本部门权限)/MyDepartAndDown(3：本部门及下署部门权限)/OnlySelf(4：仅自己能够访问权限)/ALL(9：所有，即不作限制))的1/n种，为当前程序中对指定页面的访问提供必须的权限数据支撑。

       Role： 通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【角色】实体与“[Blog].[Role]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

       Topic：通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【主题】实体与“[Blog].[Topic]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

       TaskInfoDto：该实体类及其属性成员，为调度任务(/计划)的触发和执行提供数据支撑。

       TasksQz：通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【计划任务】实体与“[Blog].[TasksQz]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

005 DepartmentRoot 、Department、

ModulesRoot 、Modules、

PermissionRoot 、Permission、

RoleModulePermissionRoot 、RoleModulePermission、

sysUserInfoRoot 、SysUserInfo、

UserRoleRoot 、UserRole、

TopicDetailRoot 、TopicDetail

       DepartmentRoot：该根部门类定义上1级部门实体整型编号值和整型编号值集。

Department：继承了DepartmentRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【部门】实体与“[Blog].[Department]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

       ModulesRoot：该根Api控制器行为方法类定义上1级Api控制器行为方法实体整型编号值。

Modules：继承了ModulesRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【Api控制器行为方法】实体与“[Blog].[Modules]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

       PermissionRoot：该根权限类定义上1级权限实体整型编号值和整型编号值集。

Permission：继承了PermissionRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【权限】实体与“[Blog].[Permission ]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

RoleModulePermissionRoot:该根角色/Api控制器行为方法/权限类定义了角色(Role)/Api控制器行为方法(Modules)/权限(Permission)3者实例之间的导航映射关系。

    RoleModulePermission：继承了RoleModulePermissionRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【角色/Api控制器行为方法/权限】实体与“[Blog].[RoleModulePermission]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

       SysUserInfoRoot:该根用户信息类定义了列表实例，该列表实例存储着1个指用户信息实例所对应所有角色的整型编号集。

SysUserInfo：继承了SysUserInfoRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【用户信息】实体与“[Blog].[SysUserInfo]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

    UserRoleRoot：该根用户/角色映射类用于构建用户信息(SysUserInfoRoot)实体与角色(Role)实体实例之间n:n的导航映射关系。

UserRole：继承了UserRoleRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【用户/角色映射】实体与“[Blog]用户/角色映射.[UserRole]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

    TopicDetailRoot：该根主题详情类用于定义的指定主题详情实例的上1级主题详情实例整型编号值。

TopicDetail：继承了TopicDetailRoot，通过该实体类及其属性成员，用于实现当前程序【Blog】.【模型】.【模型集】.【主题详情】实体与“[Blog].[TopicDetail]”表之间的CURD的交互操作，并把这些数据存储到数据库设置实例中(内存)。

注意：关于根类

我不知道“老张的哲学”通过该方式来定义实体除了炫技和程序的可读性变差之外，是否还有其它的好处，反正本人不建议使用该种定义方式来定义实体。

1 重构DBSeed类

using Common.DB;

using Common.Helper;

using Common.Helper.Console;

using Model.Models;

using System.Reflection;

using System.Text;

//Nuget--Microsoft.Extensions.Configuration.Json

using Newtonsoft.Json;

//Nuget--Magicodes.IE.Excel

using Magicodes.ExporterAndImporter.Excel;

namespace Common.Seed

{

    ///

    /// 【数据库发送类--类】

    ///

    /// 摘要：

    ///    该类用于在Code-Frist模式下，在指定的数据库软件中自动生成指定的数据库及其表，同时把指定文件中的初始化数据持久化到相应的表中。

    ///

    ///

    public class DBSeed

    {

        #region 变量--私有/保护

        ///

        /// 【发送数据文件】

        ///

        /// 摘要：

        ///     该变量用于从“wwwroot/BlogCore.Data.json”文件夹中的1个指定文件中获取1个指定实体的所有初始化实例，并把这些实例持久化到指定的表中。

        ///

        ///

        private static string SeedDataFolder = "BlogCore.Data.json/{0}.tsv";

        #endregion

        #region 方法--静态

        /// name="myContext">指示是否关闭数据库连接, 默认值：true，即自动释放数据库，如果存在事务，在事务结束后释放，而无需使用using块或者Close内置方法定义释放操作。

        /// name="WebRootPath">“wwwroot”目录的绝对路径。

        ///

        /// 【异步发送】

        ///

        ///

        /// 摘要：

        ///      在“Code-First”模式下，通过该方法把在自动指定的数据库及其表后，把文件中数据持久化到对应的表中。

        ///

        public static async Task SeedAsync(MyContext myContext, string WebRootPath)

        {

            try

            {

                //注意：在.Net项目的api模板中，默认是不包含“wwwroot”文件夹的，这需要开发者自己在api项目新建“wwwroot”文件夹。

                if (string.IsNullOrEmpty(WebRootPath))

                {

                    throw new Exception("获取wwwroot路径时，异常！");

                }

                //拼接出“wwwroot/BlogCore.Data.json”文件夹的绝对路径。

                SeedDataFolder = Path.Combine(WebRootPath, SeedDataFolder);

                Console.WriteLine("************ Blog.Core DataBase Set *****************");

                Console.WriteLine($"Is multi-DataBase: {AppSettings.app(new string[] { "MutiDBEnabled" })}");

                Console.WriteLine($"Is CQRS: {AppSettings.app(new string[] { "CQRSEnabled" })}");

                Console.WriteLine();

                Console.WriteLine($"Master DB ConId: {MyContext.ConnId}");

                Console.WriteLine($"Master DB Type: {MyContext.DbType}");

                Console.WriteLine($"Master DB ConnectString: {MyContext.ConnectionString}");

                Console.WriteLine();

                if (AppSettings.app(new string[] { "MutiDBEnabled" }).ObjToBool())

                {

                    var slaveIndex = 0;

                    BaseDBConfig.MutiConnectionString.allDbs.Where(x => x.ConnId != MainDb.CurrentDbConnId).ToList().ForEach(m =>

                    {

                        slaveIndex++;

                        Console.WriteLine($"Slave{slaveIndex} DB ID: {m.ConnId}");

                        Console.WriteLine($"Slave{slaveIndex} DB Type: {m.DbType}");

                        Console.WriteLine($"Slave{slaveIndex} DB ConnectString: {m.Connection}");

                        Console.WriteLine($"--------------------------------------");

                    });

                }

                else if (AppSettings.app(new string[] { "CQRSEnabled" }).ObjToBool())

                {

                    var slaveIndex = 0;

                    BaseDBConfig.MutiConnectionString.slaveDbs.Where(x => x.ConnId != MainDb.CurrentDbConnId).ToList().ForEach(m =>

                    {

                        slaveIndex++;

                        Console.WriteLine($"Slave{slaveIndex} DB ID: {m.ConnId}");

                        Console.WriteLine($"Slave{slaveIndex} DB Type: {m.DbType}");

                        Console.WriteLine($"Slave{slaveIndex} DB ConnectString: {m.Connection}");

                        Console.WriteLine($"--------------------------------------");

                    });

                }

                else

                {

                }

                Console.WriteLine();

                // 创建数据库

                Console.WriteLine($"在Code-Frist模式下，自动生成指定的数据库(数据库:{MyContext.ConnId})...");

               //在指定的数据库软件中自动生成指定数据库。

                if (MyContext.DbType != SqlSugar.DbType.Oracle)

                {

                    myContext.Db.DbMaintenance.CreateDatabase();

                    ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经在指定的数据库软件中自动生成指定的数据库!");

                }

                else

                {

                    //Oracle 数据库不支持该操作

                    ConsoleHelper.WriteSuccessLine($"Oracle 数据库不支持该操作，可手动创建Oracle数据库!");

                }

                // 创建数据库表，遍历指定命名空间下的class，

                Console.WriteLine("在Code-Frist模式下，开始在指定数据库中自动生成所有实体所对应的表...");

                //在指定的数据库软件中自动生成指定数据库。

                var path = AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory;

                //通过反射方式，获取当前程序中所有实体的类型实例，为自动生成相应的表提供数据支撑。

                var referencedAssemblies = Directory.GetFiles(path, "Model.dll").Select(Assembly.LoadFrom).ToArray();

                var modelTypes = referencedAssemblies

                    .SelectMany(a => a.DefinedTypes)

                    .Select(type => type.AsType())

                    .Where(x => x.IsClass && x.Namespace != null && x.Namespace.Equals("Model.Models")).ToList();

                modelTypes.ForEach(t =>

                {

                    // 这里只支持添加表，不支持删除

                    // 如果想要删除，数据库直接右键删除，或者联系SqlSugar作者；

                    if (!myContext.Db.DbMaintenance.IsAnyTable(t.Name))

                    {

                        Console.WriteLine(t.Name);

                        myContext.Db.CodeFirst.InitTables(t);

                    }

                });

                ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，在指定数据库中已经自动生成了所有实体所对应的表!");

                Console.WriteLine();

                if (AppSettings.app(new string[] { "AppSettings", "SeedDBDataEnabled" }).ObjToBool())

                {

                    JsonSerializerSettings setting = new JsonSerializerSettings();

                    JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>

                    {

                        //日期类型默认格式化处理

                        setting.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;

                        setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";

                        //空值处理

                        setting.NullValueHandling = NullValueHandling.Ignore;

                        //高级用法九中的Bool类型转换 设置

                        //setting.Converters.Add(new BoolConvert("是,否"));

                        return setting;

                    });

                    Console.WriteLine($"在Code-Frist模式下，把指定文件中的实例数据持久化到指定的表中 (数据库:{MyContext.ConnId})...");

                    //获取“Magicodes.IE.Excel”中间件实例。

                    var importer = new ExcelImporter();

                    #region 初始化数据持久化到指定表中

                    //把指定文件(wwwroot\BlogCore.Data.json\BlogArticle.tsv)中博客文章实体的所有实例，持久化到博客文章表中。

                    if (!await myContext.Db.Queryable<BlogArticle>().AnyAsync())

                    {

                        myContext.GetEntityDB<BlogArticle>().InsertRange(JsonHelper.ParseFormByJson<List<BlogArticle>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "BlogArticle"), Encoding.UTF8)));

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把博客文章(BlogArticle)实体的所有实例持久的化到了博客文章[BlogArticle]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在博客文章[BlogArticle]表，已经无法把博客文章(BlogArticle)实体的所有实例持久化到博客文章[BlogArticle]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.excel\Role.xlsx)中角色实体的所有实例，持久化到角色表中。

                    if (!await myContext.Db.Queryable<Role>().AnyAsync())

                    {

                        using var stream = new FileStream(Path.Combine(WebRootPath, "BlogCore.Data.excel", "Role.xlsx"), FileMode.Open);

                        var result = await importer.Import<Role>(stream);

                        var data = result.Data.ToList();

                        myContext.GetEntityDB<Role>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把角色(Role)的所有实例持久的化到了角色[Role]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在角色[Role]表，已经无法把角色(Role)实体的所有实例持久化到角色[Role]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\TasksQz.tsv)中计划(/调度)任务实体的所有实例，持久化到计划(/调度)任务表中。

                    if (!await myContext.Db.Queryable<TasksQz>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<TasksQz>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "TasksQz"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<TasksQz>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把计划(/调度)任务(TasksQz)实体的所有实例持久的化到了计划(/调度)任务[TasksQz]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在计划(/调度)任务[TasksQz]表，已经无法把计划(/调度)任务(TasksQz)实体的所有实例持久化到计划(/调度)任务[TasksQz]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\Topic.tsv)中主题实体的所有实例，持久化到主题表中。

                    if (!await myContext.Db.Queryable<Topic>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<Topic>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "Topic"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<Topic>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把主题(Topic)实体的所有实例持久的化到了主题[Topic]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在主题[Topic]表，已经无法把主题(Topic)实体的所有实例持久化到主题[Topic]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\TopicDetail.tsv)中主题详情实体的所有实例，持久化到主题详情表中。

                    if (!await myContext.Db.Queryable<TopicDetail>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<TopicDetail>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "TopicDetail"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<TopicDetail>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把主题详情(TopicDetail)实体的所有实例持久的化到了主题详情[TopicDetail]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在主题详情[TopicDetail]表，已经无法把主题详情(TopicDetail)实体的所有实例持久化到主题详情[TopicDetail]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\Department.tsv)中部门实体的所有实例，持久化到部门表中。

                    if (!await myContext.Db.Queryable<Department>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<Department>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "Department"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<Department>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把部门(Department)实体的所有实例持久的化到了部门[Department]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在部门[Department]表，已经无法把部门(Department)实体的所有实例持久化到部门[Department]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\Modules.tsv)中Api控制器行为方法实体的所有实例，持久化到Api控制器行为方法表中。

                    if (!await myContext.Db.Queryable<Modules>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<Modules>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "Modules"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<Modules>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把Api控制器行为方法(Modules)实体的所有实例持久的化到了Api控制器行为方法[Modules]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在Api控制器行为方法[Modules]表，已经无法把Api控制器行为方法(Modules)实体的所有实例持久化到Api控制器行为方法[Modules]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\Permission.tsv)中权限实体的所有实例，持久化到权限表中。

                    if (!await myContext.Db.Queryable<Permission>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<Permission>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "Permission"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<Permission>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把权限(ermission)实体的所有实例持久的化到了权限[Modules]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在权限[Permission]表，已经无法把权限(Permission)实体的所有实例持久化权限[Permission]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\RoleModulePermission.tsv)中角色/Api控制器行为方法/权限实体的所有实例，持久化到角色/Api控制器行为方法/权限表中。

                    if (!await myContext.Db.Queryable<RoleModulePermission>().AnyAsync())

                    {

                        var data = JsonConvert.DeserializeObject<List<RoleModulePermission>>(FileHelper.ReadFile(string.Format(SeedDataFolder, "RoleModulePermission"), Encoding.UTF8), setting);

                        myContext.GetEntityDB<RoleModulePermission>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把角色/Api控制器行为方法/权限(RoleModulePermission)实体的所有实例持久的化到了角色/Api控制器行为方法/权限[RoleModulePermission]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在角色/Api控制器行为方法/权限[RoleModulePermission]表，已经无法把角色/Api控制器行为方法/权限(RoleModulePermission)实体的所有实例持久化到角色/Api控制器行为方法/权限RoleModulePermission]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\SysUserInfo.xlsx)中用户信息实体的所有实例，持久化到用户信息表中。

                    if (!await myContext.Db.Queryable<SysUserInfo>().AnyAsync())

                    {

                        using var stream = new FileStream(Path.Combine(WebRootPath, "BlogCore.Data.excel", "SysUserInfo.xlsx"), FileMode.Open);

                        var result = await importer.Import<SysUserInfo>(stream);

                        var data = result.Data.ToList();

                        myContext.GetEntityDB<SysUserInfo>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把用户信息(SysUserInfo)实体的所有实例持久的化到了用户信息[SysUserInfo]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在用户信息[SysUserInfo]表中，已经无法把用户信息(SysUserInfo)实体的所有实例持久化到用户信息[SysUserInfo]表中！");

                    }

                    //把指定文件(wwwroot\BlogCore.Data.json\UserRole.xlsx)中用户/角色映射实体的所有实例，持久化到用户/角色映射表中。

                    if (!await myContext.Db.Queryable<UserRole>().AnyAsync())

                    {

                        using var stream = new FileStream(Path.Combine(WebRootPath, "BlogCore.Data.excel", "UserRole.xlsx"), FileMode.Open);

                        var result = await importer.Import<UserRole>(stream);

                        var data = result.Data.ToList();

                        myContext.GetEntityDB<UserRole>().InsertRange(data);

                        ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把用户/角色映射UserRole)实体的所有实例持久的化到了用户/角色映射[UserRole]表中。");

                    }

                    else

                    {

                        ConsoleHelper.WriteWarningLine("在Code-Frist模式下，指定数据库中已经存在用户/角色映射[UserRole]表中，已经无法把用户/角色映射(UserRole)实体的所有实例持久化到用户/角色映射[SysUserInfo]表中！");

                    }

                    #endregion

                    ConsoleHelper.WriteSuccessLine($"在Code-Frist模式下，已经成功把所有文件中的数据持久化到指定的表中。");

                }

                Console.WriteLine();

            }

            catch (Exception ex)

            {

                throw new Exception(

                    $"1、若是Mysql,查看常见问题:https://github.com/anjoy8/Blog.Core/issues/148#issue-776281770 \n" +

                    $"2、若是Oracle,查看常见问题:https://github.com/anjoy8/Blog.Core/issues/148#issuecomment-752340231 \n" +

                    "3、其他错误：" + ex.Message);

            }

        }

        #endregion

    }

}

2 关于.Net7日志控制台的显示：

    在Visual Studio更新到.Net7后，使用“IISExpress”方式调试程序，则会导致日志控制台不被显示，只有使用“https”方式调试程序，才会显示日志控制台。如下图所示：

 对以上功能更为具体实现和注释见：221120_02Blog(持久化初始数据到指定表)。