第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 <Tkey>、Department、

ModulesRoot <Tkey>、Modules、

PermissionRoot <Tkey>、Permission、

RoleModulePermissionRoot <Tkey>、RoleModulePermission、

sysUserInfoRoot <Tkey>、SysUserInfo、

UserRoleRoot <Tkey>、UserRole、

TopicDetailRoot <Tkey>、TopicDetail

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

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

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

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

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

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

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

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

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

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

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

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

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

TopicDetail：继承了TopicDetailRoot<Tkey>，通过该实体类及其属性成员，用于实现当前程序【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

{

/// <summary>

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

/// <remarks>

/// 摘要：

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

/// </remarks>

/// </summary>

public class DBSeed

{

#region 变量--私有/保护

/// <summary>

/// 【发送数据文件】

/// <remarks>

/// 摘要：

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

/// </remarks>

/// </summary>

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

#endregion

#region 方法--静态

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

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

/// <summary>

/// 【异步发送】

/// </summary>

/// <remarks>

/// 摘要：

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

/// </remarks>

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]表中！");