考试管理新增人工阅卷处理完成状态

master
xiaochanghai 2 weeks ago
parent bb28ad8ba9
commit 6caeda7651
  1. BIN
      Lib/Tiobon.Core.Base.dll
  2. BIN
      Lib/Tiobon.Core.dll
  3. 449
      Lib/Tiobon.Core.xml
  4. 2
      Tiobon.CodeGenerator/Program.cs
  5. 5
      Tiobon.Core.Api/Controllers/DbFirst/DbFirstController.cs
  6. 643
      Tiobon.Core.Common/Seed/DBSeed.cs
  7. 1091
      Tiobon.Core.Common/Seed/FrameSeed.cs
  8. 34
      Tiobon.Core.Common/Seed/IEntitySeedData.cs
  9. 225
      Tiobon.Core.Common/Seed/MyContext.cs
  10. 77
      Tiobon.Core.Common/Seed/SeedData/BusinessDataSeedData.cs
  11. 36
      Tiobon.Core.Common/Seed/SeedData/MultiBusinessDataSeedData.cs
  12. 36
      Tiobon.Core.Common/Seed/SeedData/MultiBusinessSubDataSeedData.cs
  13. 68
      Tiobon.Core.Common/Seed/SeedData/SubBusinessDataSeedData.cs
  14. 66
      Tiobon.Core.Common/Seed/SeedData/TenantSeedData.cs
  15. 77
      Tiobon.Core.Common/Seed/SeedData/UserInfoSeedData.cs
  16. 1
      Tiobon.Core.Extensions/AutoMapper/CustomProfile.cs
  17. 3
      Tiobon.Core.Extensions/HostedService/SeedDataHostedService.cs
  18. 2
      Tiobon.Core.Extensions/ServiceExtensions/DbSetup.cs
  19. 2
      Tiobon.Core.Jobs/Helper.cs
  20. 18
      Tiobon.Core.Model/Models/RootTkey/sysUserInfoRoot.cs
  21. 26
      Tiobon.Core.Model/Models/Tenant/BusinessTable.cs
  22. 11
      Tiobon.Core.Model/Models/Tenant/MultiBusinessSubTable.cs
  23. 21
      Tiobon.Core.Model/Models/Tenant/MultiBusinessTable.cs
  24. 19
      Tiobon.Core.Model/Models/Tenant/SubLibraryBusinessTable.cs
  25. 139
      Tiobon.Core.Model/Models/sysUserInfo.cs
  26. 13
      Tiobon.Core.Model/ViewModels/RootTKey/SysUserInfoDtoRoot.cs
  27. 24
      Tiobon.Core.Model/ViewModels/SysUserInfoDto.cs
  28. 5
      Tiobon.Core.Services/TenantService.cs
  29. 1
      Tiobon.Core.Tests/Common_Test/DynamicLambdaTest.cs
  30. 2
      Tiobon.Core.Tests/DependencyInjection/DI_Test.cs
  31. 138
      Tiobon.Core/Tiobon.Core.Model.xml

Binary file not shown.

Binary file not shown.

@ -3466,6 +3466,144 @@
备注 备注
</summary> </summary>
</member> </member>
<member name="T:Tiobon.Core.Model.SysUserInfo">
<summary>
用户信息表
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.LoginName">
<summary>
登录账号
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.LoginPWD">
<summary>
登录密码
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.RealName">
<summary>
真实姓名
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.Status">
<summary>
状态
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.DepartmentId">
<summary>
部门
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.Remark">
<summary>
备注
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.CreateTime">
<summary>
创建时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.UpdateTime">
<summary>
更新时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.CriticalModifyTime">
<summary>
关键业务修改时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.LastErrorTime">
<summary>
最后异常时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.ErrorCount">
<summary>
错误次数
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.Name">
<summary>
登录账号
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfo.TenantId">
<summary>
租户Id
</summary>
</member>
<member name="T:Tiobon.Core.Model.SysUserInfoRoot`1">
<summary>
用户信息表
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfoRoot`1.Id">
<summary>
Id
泛型主键Tkey
</summary>
</member>
<member name="T:Tiobon.Core.Model.BusinessTable">
<summary>
业务数据 <br/>
多租户 (Id 隔离)
</summary>
</member>
<member name="P:Tiobon.Core.Model.BusinessTable.TenantId">
<summary>
无需手动赋值
</summary>
</member>
<member name="P:Tiobon.Core.Model.BusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.BusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="T:Tiobon.Core.Model.MultiBusinessSubTable">
<summary>
多租户-多表方案 业务表 子表 <br/>
</summary>
</member>
<member name="T:Tiobon.Core.Model.MultiBusinessTable">
<summary>
多租户-多表方案 业务表 <br/>
</summary>
</member>
<member name="P:Tiobon.Core.Model.MultiBusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.MultiBusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="T:Tiobon.Core.Model.SubLibraryBusinessTable">
<summary>
多租户-多库方案 业务表 <br/>
公共库无需标记[MultiTenant]特性
</summary>
</member>
<member name="P:Tiobon.Core.Model.SubLibraryBusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.SubLibraryBusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="M:Tiobon.Core.Option.Core.ConfigurableOptions.AddConfigurableOptions``1(Microsoft.Extensions.DependencyInjection.IServiceCollection)"> <member name="M:Tiobon.Core.Option.Core.ConfigurableOptions.AddConfigurableOptions``1(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
<summary>添加选项配置</summary> <summary>添加选项配置</summary>
<typeparam name="TOptions">选项类型</typeparam> <typeparam name="TOptions">选项类型</typeparam>
@ -3514,6 +3652,317 @@
地址 地址
</summary> </summary>
</member> </member>
<member name="M:Tiobon.Core.Seed.DBSeed.SeedAsync(Tiobon.Core.Seed.MyContext,System.String)">
<summary>
异步添加种子数据
</summary>
<param name="myContext"></param>
<param name="WebRootPath"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.DBSeed.SeedDataAsync(SqlSugar.ISqlSugarClient)">
<summary>
种子初始化数据
</summary>
<param name="myContext"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.DBSeed.MigrationLogs(Tiobon.Core.Seed.MyContext)">
<summary>
迁移日志数据库
</summary>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.DBSeed.TenantSeedAsync(Tiobon.Core.Seed.MyContext)">
<summary>
初始化 多租户
</summary>
<param name="myContext"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.DBSeed.InitTenantSeedAsync(SqlSugar.ITenant,SqlSugar.ConnectionConfig)">
<summary>
初始化多库
</summary>
<param name="itenant"></param>
<param name="config"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateControllers(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成Controller层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<param name="isMuti"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateModels(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成Model层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<param name="isMuti"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateIRepositorys(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成IRepository层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="isMuti"></param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateIServices(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成 IService 层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="isMuti"></param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateRepository(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成 Repository 层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="isMuti"></param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateServices(SqlSugar.SqlSugarScope,System.String,System.Boolean,System.String[])">
<summary>
生成 Service 层
</summary>
<param name="sqlSugarClient">sqlsugar实例</param>
<param name="ConnId">数据库链接ID</param>
<param name="isMuti"></param>
<param name="tableNames">数据库表名数组,默认空,生成所有表</param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_Controller_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean,System.Boolean)">
<summary>
根据数据库表生产Controller层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
<param name="blnSerializable">是否序列化</param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_Model_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean,System.Boolean)">
<summary>
根据数据库表生产Model层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
<param name="blnSerializable">是否序列化</param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_IRepository_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean)">
<summary>
根据数据库表生产IRepository层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_IServices_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean)">
<summary>
根据数据库表生产IServices层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_Repository_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean)">
<summary>
根据数据库表生产 Repository 层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.Create_Services_ClassFileByDBTalbe(SqlSugar.SqlSugarScope,System.String,System.String,System.String,System.String[],System.String,System.Boolean)">
<summary>
根据数据库表生产 Services 层
</summary>
<param name="sqlSugarClient"></param>
<param name="ConnId">数据库链接ID</param>
<param name="strPath">实体类存放路径</param>
<param name="strNameSpace">命名空间</param>
<param name="lstTableNames">生产指定的表</param>
<param name="strInterface">实现接口</param>
<param name="isMuti"></param>
</member>
<member name="M:Tiobon.Core.Seed.FrameSeed.CreateFilesByClassStringList(System.Collections.Generic.Dictionary{System.String,System.String},System.String,System.String)">
<summary>
根据模板内容批量生成文件
</summary>
<param name="ls">类文件字符串list</param>
<param name="strPath">生成路径</param>
<param name="fileNameTp">文件名格式模板</param>
</member>
<member name="T:Tiobon.Core.Seed.IEntitySeedData`1">
<summary>
种子数据 接口
</summary>
<typeparam name="T"></typeparam>
</member>
<member name="M:Tiobon.Core.Seed.IEntitySeedData`1.InitSeedData">
<summary>
初始化种子数据 <br/>
只要表不存在数据,程序启动就会自动初始化
</summary>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.IEntitySeedData`1.SeedData">
<summary>
种子数据 <br/>
存在不操作、不存在Insert <br/>
适合系统内置数据,项目开发后续增加内置数据
</summary>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.IEntitySeedData`1.CustomizeSeedData(SqlSugar.ISqlSugarClient)">
<summary>
自定义操作 <br/>
以上满不足了,可以自己编写
</summary>
<param name="db"></param>
<returns></returns>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetMainConnectionDb">
<summary>
连接字符串
Tiobon.Core
</summary>
</member>
<member name="P:Tiobon.Core.Seed.MyContext.ConnectionString">
<summary>
连接字符串
Tiobon.Core
</summary>
</member>
<member name="P:Tiobon.Core.Seed.MyContext.DbType">
<summary>
数据库类型
Tiobon.Core
</summary>
</member>
<member name="P:Tiobon.Core.Seed.MyContext.Db">
<summary>
数据连接对象
Tiobon.Core
</summary>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.#ctor(SqlSugar.ISqlSugarClient)">
<summary>
功能描述:构造函数
  者:Tiobon.Core
</summary>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetEntityDB``1">
<summary>
功能描述:获取数据库处理对象
  者:Tiobon.Core
</summary>
<returns>返回值</returns>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.CreateTableByEntity``1(System.Boolean,``0[])">
<summary>
功能描述:根据实体类生成数据库表
  者:Tiobon.Core
</summary>
<param name="blnBackupTable">是否备份表</param>
<param name="lstEntitys">指定的实体</param>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.CreateTableByEntity(System.Boolean,System.Type[])">
<summary>
功能描述:根据实体类生成数据库表
  者:Tiobon.Core
</summary>
<param name="blnBackupTable">是否备份表</param>
<param name="lstEntitys">指定的实体</param>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.Init(System.String,SqlSugar.DbType)">
<summary>
功能描述:设置初始化参数
  者:Tiobon.Core
</summary>
<param name="strConnectionString">连接字符串</param>
<param name="enmDbType">数据库类型</param>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetConnectionConfig(System.Boolean,System.Boolean)">
<summary>
功能描述:创建一个链接配置
  者:Tiobon.Core
</summary>
<param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
<param name="blnIsShardSameThread">是否夸类事务</param>
<returns>ConnectionConfig</returns>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetCustomDB(SqlSugar.ConnectionConfig)">
<summary>
功能描述:获取一个自定义的DB
  者:Tiobon.Core
</summary>
<param name="config">config</param>
<returns>返回值</returns>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetCustomEntityDB``1(SqlSugar.SqlSugarScope)">
<summary>
功能描述:获取一个自定义的数据库处理对象
  者:Tiobon.Core
</summary>
<param name="sugarClient">sugarClient</param>
<returns>返回值</returns>
</member>
<member name="M:Tiobon.Core.Seed.MyContext.GetCustomEntityDB``1(SqlSugar.ConnectionConfig)">
<summary>
功能描述:获取一个自定义的数据库处理对象
  者:Tiobon.Core
</summary>
<param name="config">config</param>
<returns>返回值</returns>
</member>
<member name="T:Tiobon.Core.Seed.SeedData.BusinessDataSeedData">
<summary>
初始化 业务数据
</summary>
</member>
<member name="T:Tiobon.Core.Seed.SeedData.TenantSeedData">
<summary>
租户 种子数据
</summary>
</member>
<member name="T:Tiobon.Core.Swagger.SwaggerContextExtension"> <member name="T:Tiobon.Core.Swagger.SwaggerContextExtension">
<summary> <summary>

@ -1,7 +1,7 @@
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using SqlSugar; using SqlSugar;
using Tiobon.Core; using Tiobon.Core;
using Tiobon.Core.Common.Seed; using Tiobon.Core.Seed;
using Tiobon.Core.DB; using Tiobon.Core.DB;
using Tiobon.Core.DB.Dapper.Extensions; using Tiobon.Core.DB.Dapper.Extensions;
using Tiobon.Core.Extensions; using Tiobon.Core.Extensions;

@ -1,7 +1,6 @@
using Tiobon.Core.Common.DB; using SqlSugar;
using Tiobon.Core.Common.Seed;
using SqlSugar;
using Tiobon.Core.DB; using Tiobon.Core.DB;
using Tiobon.Core.Seed;
namespace Tiobon.Core.Controllers; namespace Tiobon.Core.Controllers;

@ -1,643 +0,0 @@
using Newtonsoft.Json;
using SqlSugar;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using Tiobon.Core.Common.DB;
using Tiobon.Core.Extensions;
using Tiobon.Core.Const;
using Tiobon.Core.DB;
using Tiobon.Core.Helper;
using Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants;
using Tiobon.Core.Model;
namespace Tiobon.Core.Common.Seed;
public class DBSeed
{
private static string SeedDataFolder = "TiobonCore.Data.json/{0}.tsv";
/// <summary>
/// 异步添加种子数据
/// </summary>
/// <param name="myContext"></param>
/// <param name="WebRootPath"></param>
/// <returns></returns>
public static async Task SeedAsync(MyContext myContext, string WebRootPath)
{
try
{
if (string.IsNullOrEmpty(WebRootPath))
{
throw new Exception("获取wwwroot路径时,异常!");
}
SeedDataFolder = Path.Combine(WebRootPath, SeedDataFolder);
Console.WriteLine("************ Tiobon.Core DataBase Set *****************");
Console.WriteLine($"Master DB ConId: {myContext.Db.CurrentConnectionConfig.ConfigId}");
Console.WriteLine($"Master DB Type: {myContext.Db.CurrentConnectionConfig.DbType}");
Console.WriteLine($"Master DB ConnectString: {myContext.Db.CurrentConnectionConfig.ConnectionString}");
Console.WriteLine();
if (BaseDBConfig.MainConfig.SlaveConnectionConfigs.AnyNoException())
{
var index = 0;
BaseDBConfig.MainConfig.SlaveConnectionConfigs.ForEach(m =>
{
index++;
Console.WriteLine($"Slave{index} DB HitRate: {m.HitRate}");
Console.WriteLine($"Slave{index} DB ConnectString: {m.ConnectionString}");
Console.WriteLine($"--------------------------------------");
});
}
else if (BaseDBConfig.ReuseConfigs.AnyNoException())
{
var index = 0;
BaseDBConfig.ReuseConfigs.ForEach(m =>
{
index++;
Console.WriteLine($"Reuse{index} DB ID: {m.ConfigId}");
Console.WriteLine($"Reuse{index} DB Type: {m.DbType}");
Console.WriteLine($"Reuse{index} DB ConnectString: {m.ConnectionString}");
Console.WriteLine($"--------------------------------------");
});
}
Console.WriteLine();
// 创建数据库
Console.WriteLine($"Create Database(The Db Id:{MyContext.ConnId})...");
if (MyContext.DbType != SqlSugar.DbType.Oracle && MyContext.DbType != SqlSugar.DbType.Dm)
{
myContext.Db.DbMaintenance.CreateDatabase();
ConsoleHelper.WriteSuccessLine($"Database created successfully!");
}
else
{
//Oracle 数据库不支持该操作
ConsoleHelper.WriteSuccessLine($"Oracle 数据库不支持该操作,可手动创建Oracle/Dm数据库!");
}
// 创建数据库表,遍历指定命名空间下的class,
// 注意不要把其他命名空间下的也添加进来。
Console.WriteLine("Create Tables...");
var path = AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory;
var referencedAssemblies = System.IO.Directory.GetFiles(path, "Tiobon.Core.Model.dll")
.Select(Assembly.LoadFrom).ToArray();
var modelTypes = referencedAssemblies
.SelectMany(a => a.DefinedTypes)
.Select(type => type.AsType())
.Where(x => x.IsClass && x.Namespace is "Tiobon.Core.Model.Models")
.Where(s => !s.IsDefined(typeof(MultiTenantAttribute), false))
.ToList();
modelTypes.ForEach(t =>
{
// 这里只支持添加表,不支持删除
// 如果想要删除,数据库直接右键删除,或者联系SqlSugar作者;
if (!myContext.Db.DbMaintenance.IsAnyTable(t.Name))
{
Console.WriteLine(t.Name);
myContext.Db.CodeFirst.SplitTables().InitTables(t);
}
});
ConsoleHelper.WriteSuccessLine($"Tables created successfully!");
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($"Seeding database data (The Db Id:{MyContext.ConnId})...");
//var importer = new ExcelImporter();
#region TiobonArticle
if (!await myContext.Db.Queryable<TiobonArticle>().AnyAsync())
{
myContext.GetEntityDB<TiobonArticle>().InsertRange(
JsonHelper.ParseFormByJson<List<TiobonArticle>>(
FileHelper.ReadFile(string.Format(SeedDataFolder, "TiobonArticle"), Encoding.UTF8)));
Console.WriteLine("Table:TiobonArticle created success!");
}
else
{
Console.WriteLine("Table:TiobonArticle already exists...");
}
#endregion
#region Modules
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);
Console.WriteLine("Table:Modules created success!");
}
else
{
Console.WriteLine("Table:Modules already exists...");
}
#endregion
#region Permission
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);
Console.WriteLine("Table:Permission created success!");
}
else
{
Console.WriteLine("Table:Permission already exists...");
}
#endregion
#region Role
if (!await myContext.Db.Queryable<Role>().AnyAsync())
{
var data = JsonConvert.DeserializeObject<List<Role>>(
FileHelper.ReadFile(string.Format(SeedDataFolder, "Role"), Encoding.UTF8), setting);
//using var stream = new FileStream(Path.Combine(WebRootPath, "TiobonCore.Data.excel", "Role.xlsx"), FileMode.Open);
//var result = await importer.Import<Role>(stream);
//var data = result.Data.ToList();
myContext.GetEntityDB<Role>().InsertRange(data);
Console.WriteLine("Table:Role created success!");
}
else
{
Console.WriteLine("Table:Role already exists...");
}
#endregion
#region RoleModulePermission
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);
Console.WriteLine("Table:RoleModulePermission created success!");
}
else
{
Console.WriteLine("Table:RoleModulePermission already exists...");
}
#endregion
#region Topic
//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);
// Console.WriteLine("Table:Topic created success!");
//}
//else
//{
// Console.WriteLine("Table:Topic already exists...");
//}
#endregion
#region TopicDetail
//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);
// Console.WriteLine("Table:TopicDetail created success!");
//}
//else
//{
// Console.WriteLine("Table:TopicDetail already exists...");
//}
#endregion
#region UserRole
if (!await myContext.Db.Queryable<UserRole>().AnyAsync())
{
var data = JsonConvert.DeserializeObject<List<UserRole>>(
FileHelper.ReadFile(string.Format(SeedDataFolder, "UserRole"), Encoding.UTF8), setting);
myContext.GetEntityDB<UserRole>().InsertRange(data);
Console.WriteLine("Table:UserRole created success!");
}
else
{
Console.WriteLine("Table:UserRole already exists...");
}
#endregion
#region sysUserInfo
if (!await myContext.Db.Queryable<SysUserInfo>().AnyAsync())
{
var data = JsonConvert.DeserializeObject<List<SysUserInfo>>(
FileHelper.ReadFile(string.Format(SeedDataFolder, "sysUserInfo"), Encoding.UTF8), setting);
myContext.GetEntityDB<SysUserInfo>().InsertRange(data);
Console.WriteLine("Table:sysUserInfo created success!");
}
else
{
Console.WriteLine("Table:sysUserInfo already exists...");
}
#endregion
#region TasksQz
if (!await myContext.Db.Queryable<Ghre_TasksQz>().AnyAsync())
{
var data = JsonConvert.DeserializeObject<List<Ghre_TasksQz>>(
FileHelper.ReadFile(string.Format(SeedDataFolder, "TasksQz"), Encoding.UTF8), setting);
myContext.GetEntityDB<Ghre_TasksQz>().InsertRange(data);
Console.WriteLine("Table:TasksQz created success!");
}
else
{
Console.WriteLine("Table:TasksQz already exists...");
}
#endregion
#region TasksLog
if (!await myContext.Db.Queryable<Ghre_TasksLog>().AnyAsync())
{
Console.WriteLine("Table:TasksLog created success!");
}
else
{
Console.WriteLine("Table:TasksLog already exists...");
}
#endregion
#region Department
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);
Console.WriteLine("Table:Department created success!");
}
else
{
Console.WriteLine("Table:Department already exists...");
}
#endregion
//种子初始化
await SeedDataAsync(myContext.Db);
ConsoleHelper.WriteSuccessLine($"Done seeding database!");
}
Console.WriteLine();
}
catch (Exception ex)
{
throw new Exception(
$"1、若是Mysql,查看常见问题:https://github.com/anjoy8/Tiobon.Core/issues/148#issue-776281770 \n" +
$"2、若是Oracle,查看常见问题:https://github.com/anjoy8/Tiobon.Core/issues/148#issuecomment-752340231 \n" +
"3、其他错误:" + ex.Message);
}
}
/// <summary>
/// 种子初始化数据
/// </summary>
/// <param name="myContext"></param>
/// <returns></returns>
private static async Task SeedDataAsync(ISqlSugarClient db)
{
// 获取所有种子配置-初始化数据
var seedDataTypes = AssemblysExtensions.GetAllAssemblies().SelectMany(s => s.DefinedTypes)
.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass)
.Where(u =>
{
var esd = u.GetInterfaces()
.FirstOrDefault(i => i.HasImplementedRawGeneric(typeof(IEntitySeedData<>)));
if (esd is null)
{
return false;
}
var eType = esd.GenericTypeArguments[0];
if (eType.GetCustomAttribute<MultiTenantAttribute>() is null)
{
return true;
}
return false;
});
if (!seedDataTypes.Any()) return;
foreach (var seedType in seedDataTypes)
{
dynamic instance = Activator.CreateInstance(seedType);
//初始化数据
{
var seedData = instance.InitSeedData();
if (seedData != null && Enumerable.Any(seedData))
{
var entityType = seedType.GetInterfaces().First().GetGenericArguments().First();
var entity = db.EntityMaintenance.GetEntityInfo(entityType);
if (!await db.Queryable(entity.DbTableName, "").AnyAsync())
{
await db.Insertable(Enumerable.ToList(seedData)).ExecuteCommandAsync();
Console.WriteLine($"Table:{entity.DbTableName} init success!");
}
}
}
//种子数据
{
var seedData = instance.SeedData();
if (seedData != null && Enumerable.Any(seedData))
{
var entityType = seedType.GetInterfaces().First().GetGenericArguments().First();
var entity = db.EntityMaintenance.GetEntityInfo(entityType);
await db.Storageable(Enumerable.ToList(seedData)).ExecuteCommandAsync();
Console.WriteLine($"Table:{entity.DbTableName} seedData success!");
}
}
//自定义处理
{
await instance.CustomizeSeedData(db);
}
}
}
/// <summary>
/// 迁移日志数据库
/// </summary>
/// <returns></returns>
public static void MigrationLogs(MyContext myContext)
{
// 创建数据库表,遍历指定命名空间下的class,
// 注意不要把其他命名空间下的也添加进来。
Console.WriteLine("Create Log Tables...");
if (!myContext.Db.IsAnyConnection(SqlSugarConst.LogConfigId.ToLower()))
{
throw new ApplicationException("未配置日志数据库,请在appsettings.json中DBS节点中配置");
}
var logDb = myContext.Db.GetConnection(SqlSugarConst.LogConfigId.ToLower());
Console.WriteLine($"Create log Database(The Db Id:{SqlSugarConst.LogConfigId.ToLower()})...");
logDb.DbMaintenance.CreateDatabase();
ConsoleHelper.WriteSuccessLine($"Log Database created successfully!");
var path = AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory;
var referencedAssemblies = System.IO.Directory.GetFiles(path, "Tiobon.Core.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.StartsWith("Tiobon.Core.Model.Logs"))
.ToList();
Stopwatch sw = Stopwatch.StartNew();
var tables = logDb.DbMaintenance.GetTableInfoList();
modelTypes.ForEach(t =>
{
// 这里只支持添加修改表,不支持删除
// 如果想要删除,数据库直接右键删除,或者联系SqlSugar作者;
if (!tables.Any(s => s.Name.Contains(t.Name)))
{
Console.WriteLine(t.Name);
if (t.GetCustomAttribute<SplitTableAttribute>() != null)
{
logDb.CodeFirst.SplitTables().InitTables(t);
}
else
{
logDb.CodeFirst.InitTables(t);
}
}
});
sw.Stop();
$"Log Tables created successfully! {sw.ElapsedMilliseconds}ms".WriteSuccessLine();
Console.WriteLine();
}
/// <summary>
/// 初始化 多租户
/// </summary>
/// <param name="myContext"></param>
/// <returns></returns>
public static async Task TenantSeedAsync(MyContext myContext)
{
var tenants = await myContext.Db.Queryable<SysTenant>().Where(s => s.TenantType == TenantTypeEnum.Db)
.ToListAsync();
if (tenants.Any())
{
Console.WriteLine($@"Init Multi Tenant Db");
foreach (var tenant in tenants)
{
Console.WriteLine($@"Init Multi Tenant Db : {tenant.ConfigId}/{tenant.Name}");
await InitTenantSeedAsync(myContext.Db.AsTenant(), tenant.GetConnectionConfig());
}
}
tenants = await myContext.Db.Queryable<SysTenant>().Where(s => s.TenantType == TenantTypeEnum.Tables)
.ToListAsync();
if (tenants.Any())
{
await InitTenantSeedAsync(myContext, tenants);
}
}
#region 多租户 多表 初始化
private static async Task InitTenantSeedAsync(MyContext myContext, List<SysTenant> tenants)
{
ConsoleHelper.WriteInfoLine($"Init Multi Tenant Tables : {myContext.Db.CurrentConnectionConfig.ConfigId}");
// 获取所有实体表-初始化租户业务表
var entityTypes = TenantUtil.GetTenantEntityTypes(TenantTypeEnum.Tables);
if (!entityTypes.Any()) return;
foreach (var sysTenant in tenants)
{
foreach (var entityType in entityTypes)
{
myContext.Db.CodeFirst
.As(entityType, entityType.GetTenantTableName(myContext.Db, sysTenant))
.InitTables(entityType);
Console.WriteLine($@"Init Tables:{entityType.GetTenantTableName(myContext.Db, sysTenant)}");
}
myContext.Db.SetTenantTable(sysTenant.Id.ToString());
//多租户初始化种子数据
await TenantSeedDataAsync(myContext.Db, TenantTypeEnum.Tables);
}
ConsoleHelper.WriteSuccessLine(
$"Init Multi Tenant Tables : {myContext.Db.CurrentConnectionConfig.ConfigId} created successfully!");
}
#endregion
#region 多租户 多库 初始化
/// <summary>
/// 初始化多库
/// </summary>
/// <param name="itenant"></param>
/// <param name="config"></param>
/// <returns></returns>
public static async Task InitTenantSeedAsync(ITenant itenant, ConnectionConfig config)
{
itenant.RemoveConnection(config.ConfigId);
itenant.AddConnection(config);
var db = itenant.GetConnectionScope(config.ConfigId);
db.DbMaintenance.CreateDatabase();
ConsoleHelper.WriteSuccessLine($"Init Multi Tenant Db : {config.ConfigId} Database created successfully!");
Console.WriteLine($@"Init Multi Tenant Db : {config.ConfigId} Create Tables");
// 获取所有实体表-初始化租户业务表
var entityTypes = TenantUtil.GetTenantEntityTypes(TenantTypeEnum.Db);
if (!entityTypes.Any()) return;
foreach (var entityType in entityTypes)
{
var splitTable = entityType.GetCustomAttribute<SplitTableAttribute>();
if (splitTable == null)
db.CodeFirst.InitTables(entityType);
else
db.CodeFirst.SplitTables().InitTables(entityType);
Console.WriteLine(entityType.Name);
}
//多租户初始化种子数据
await TenantSeedDataAsync(db, TenantTypeEnum.Db);
}
#endregion
#region 多租户 种子数据 初始化
private static async Task TenantSeedDataAsync(ISqlSugarClient db, TenantTypeEnum tenantType)
{
// 获取所有种子配置-初始化数据
var seedDataTypes = AssemblysExtensions.GetAllAssemblies().SelectMany(s => s.DefinedTypes)
.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass)
.Where(u =>
{
var esd = u.GetInterfaces()
.FirstOrDefault(i => i.HasImplementedRawGeneric(typeof(IEntitySeedData<>)));
if (esd is null)
{
return false;
}
var eType = esd.GenericTypeArguments[0];
return eType.IsTenantEntity(tenantType);
});
if (!seedDataTypes.Any()) return;
foreach (var seedType in seedDataTypes)
{
dynamic instance = Activator.CreateInstance(seedType);
//初始化数据
{
var seedData = instance.InitSeedData();
if (seedData != null && Enumerable.Any(seedData))
{
var entityType = seedType.GetInterfaces().First().GetGenericArguments().First();
var entity = db.EntityMaintenance.GetEntityInfo(entityType);
if (!await db.Queryable(entity.DbTableName, "").AnyAsync())
{
await db.Insertable(Enumerable.ToList(seedData)).ExecuteCommandAsync();
Console.WriteLine($"Table:{entity.DbTableName} init success!");
}
}
}
//种子数据
{
var seedData = instance.SeedData();
if (seedData != null && Enumerable.Any(seedData))
{
var entityType = seedType.GetInterfaces().First().GetGenericArguments().First();
var entity = db.EntityMaintenance.GetEntityInfo(entityType);
await db.Storageable(Enumerable.ToList(seedData)).ExecuteCommandAsync();
Console.WriteLine($"Table:{entity.DbTableName} seedData success!");
}
}
//自定义处理
{
await instance.CustomizeSeedData(db);
}
}
}
#endregion
}

File diff suppressed because it is too large Load Diff

@ -1,34 +0,0 @@
using SqlSugar;
namespace Tiobon.Core.Common.Seed;
/// <summary>
/// 种子数据 接口
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IEntitySeedData<out T>
where T : class, new()
{
/// <summary>
/// 初始化种子数据 <br/>
/// 只要表不存在数据,程序启动就会自动初始化
/// </summary>
/// <returns></returns>
IEnumerable<T> InitSeedData();
/// <summary>
/// 种子数据 <br/>
/// 存在不操作、不存在Insert <br/>
/// 适合系统内置数据,项目开发后续增加内置数据
/// </summary>
/// <returns></returns>
IEnumerable<T> SeedData();
/// <summary>
/// 自定义操作 <br/>
/// 以上满不足了,可以自己编写
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
Task CustomizeSeedData(ISqlSugarClient db);
}

@ -1,225 +0,0 @@
using SqlSugar;
using Tiobon.Core.DB;
namespace Tiobon.Core.Common.Seed;
public class MyContext
{
private static MutiDBOperate connectObject => GetMainConnectionDb();
private static string _connectionString = connectObject.Connection;
private static DbType _dbType = (DbType)connectObject.DbType;
public static string ConnId = connectObject.ConnId;
private SqlSugarScope _db;
/// <summary>
/// 连接字符串
/// Tiobon.Core
/// </summary>
public static MutiDBOperate GetMainConnectionDb()
{
var mainConnetctDb = BaseDBConfig.MutiConnectionString.allDbs.Find(x => x.ConnId == MainDb.CurrentDbConnId);
if (BaseDBConfig.MutiConnectionString.allDbs.Count > 0)
{
if (mainConnetctDb == null)
{
mainConnetctDb = BaseDBConfig.MutiConnectionString.allDbs[0];
}
}
else
{
throw new Exception("请确保appsettigns.json中配置连接字符串,并设置Enabled为true;");
}
return mainConnetctDb;
}
/// <summary>
/// 连接字符串
/// Tiobon.Core
/// </summary>
public static string ConnectionString
{
get { return _connectionString; }
set { _connectionString = value; }
}
/// <summary>
/// 数据库类型
/// Tiobon.Core
/// </summary>
public static DbType DbType
{
get { return _dbType; }
set { _dbType = value; }
}
/// <summary>
/// 数据连接对象
/// Tiobon.Core
/// </summary>
public SqlSugarScope Db
{
get { return _db; }
private set { _db = value; }
}
/// <summary>
/// 功能描述:构造函数
/// 作  者:Tiobon.Core
/// </summary>
public MyContext(ISqlSugarClient sqlSugarClient)
{
if (string.IsNullOrEmpty(_connectionString))
throw new ArgumentNullException("数据库连接字符串为空");
_db = sqlSugarClient as SqlSugarScope;
}
#region 实例方法
/// <summary>
/// 功能描述:获取数据库处理对象
/// 作  者:Tiobon.Core
/// </summary>
/// <returns>返回值</returns>
public SimpleClient<T> GetEntityDB<T>() where T : class, new()
{
return new SimpleClient<T>(_db);
}
/// <summary>
/// 功能描述:获取数据库处理对象
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="db">db</param>
/// <returns>返回值</returns>
//public SimpleClient<T> GetEntityDB<T>(SqlSugarClient db) where T : class, new()
//{
// return new SimpleClient<T>(db);
//}
#endregion
#region 根据实体类生成数据库表
/// <summary>
/// 功能描述:根据实体类生成数据库表
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="blnBackupTable">是否备份表</param>
/// <param name="lstEntitys">指定的实体</param>
public void CreateTableByEntity<T>(bool blnBackupTable, params T[] lstEntitys) where T : class, new()
{
Type[] lstTypes = null;
if (lstEntitys != null)
{
lstTypes = new Type[lstEntitys.Length];
for (int i = 0; i < lstEntitys.Length; i++)
{
T t = lstEntitys[i];
lstTypes[i] = typeof(T);
}
}
CreateTableByEntity(blnBackupTable, lstTypes);
}
/// <summary>
/// 功能描述:根据实体类生成数据库表
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="blnBackupTable">是否备份表</param>
/// <param name="lstEntitys">指定的实体</param>
public void CreateTableByEntity(bool blnBackupTable, params Type[] lstEntitys)
{
if (blnBackupTable)
{
_db.CodeFirst.BackupTable().InitTables(lstEntitys); //change entity backupTable
}
else
{
_db.CodeFirst.InitTables(lstEntitys);
}
}
#endregion
#region 静态方法
///// <summary>
///// 功能描述:获得一个DbContext
///// 作  者:Tiobon.Core
///// </summary>
///// <returns></returns>
//public static MyContext GetDbContext()
//{
// return new MyContext();
//}
/// <summary>
/// 功能描述:设置初始化参数
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="strConnectionString">连接字符串</param>
/// <param name="enmDbType">数据库类型</param>
public static void Init(string strConnectionString, DbType enmDbType = SqlSugar.DbType.SqlServer)
{
_connectionString = strConnectionString;
_dbType = enmDbType;
}
/// <summary>
/// 功能描述:创建一个链接配置
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
/// <param name="blnIsShardSameThread">是否夸类事务</param>
/// <returns>ConnectionConfig</returns>
public static ConnectionConfig GetConnectionConfig(bool blnIsAutoCloseConnection = true, bool blnIsShardSameThread = false)
{
ConnectionConfig config = new ConnectionConfig()
{
ConnectionString = _connectionString,
DbType = _dbType,
IsAutoCloseConnection = blnIsAutoCloseConnection,
ConfigureExternalServices = new ConfigureExternalServices()
{
//DataInfoCacheService = new HttpRuntimeCache()
},
//IsShardSameThread = blnIsShardSameThread
};
return config;
}
/// <summary>
/// 功能描述:获取一个自定义的DB
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="config">config</param>
/// <returns>返回值</returns>
public static SqlSugarScope GetCustomDB(ConnectionConfig config)
{
return new SqlSugarScope(config);
}
/// <summary>
/// 功能描述:获取一个自定义的数据库处理对象
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="sugarClient">sugarClient</param>
/// <returns>返回值</returns>
public static SimpleClient<T> GetCustomEntityDB<T>(SqlSugarScope sugarClient) where T : class, new()
{
return new SimpleClient<T>(sugarClient);
}
/// <summary>
/// 功能描述:获取一个自定义的数据库处理对象
/// 作  者:Tiobon.Core
/// </summary>
/// <param name="config">config</param>
/// <returns>返回值</returns>
public static SimpleClient<T> GetCustomEntityDB<T>(ConnectionConfig config) where T : class, new()
{
SqlSugarScope sugarClient = GetCustomDB(config);
return GetCustomEntityDB<T>(sugarClient);
}
#endregion
}

@ -1,77 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Models;
namespace Tiobon.Core.Common.Seed.SeedData;
/// <summary>
/// 初始化 业务数据
/// </summary>
public class BusinessDataSeedData : IEntitySeedData<BusinessTable>
{
public IEnumerable<BusinessTable> InitSeedData()
{
return new[]
{
new BusinessTable()
{
Id = 1,
TenantId = 1000001,
Name = "张三的数据01",
Amount = 150,
IsDeleted = true,
},
new BusinessTable()
{
Id = 2,
TenantId = 1000001,
Name = "张三的数据02",
Amount = 200,
},
new BusinessTable()
{
Id = 3,
TenantId = 1000001,
Name = "张三的数据03",
Amount = 250,
},
new BusinessTable()
{
Id = 4,
TenantId = 1000002,
Name = "李四的数据01",
Amount = 300,
},
new BusinessTable()
{
Id = 5,
TenantId = 1000002,
Name = "李四的数据02",
Amount = 500,
},
new BusinessTable()
{
Id = 6,
TenantId = 0,
Name = "公共数据01",
Amount = 16600,
},
new BusinessTable()
{
Id = 7,
TenantId = 0,
Name = "公共数据02",
Amount = 19800,
},
};
}
public IEnumerable<BusinessTable> SeedData()
{
return default;
}
public Task CustomizeSeedData(ISqlSugarClient db)
{
return Task.CompletedTask;
}
}

@ -1,36 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Models;
namespace Tiobon.Core.Common.Seed.SeedData;
public class MultiBusinessDataSeedData : IEntitySeedData<MultiBusinessTable>
{
public IEnumerable<MultiBusinessTable> InitSeedData()
{
return new List<MultiBusinessTable>()
{
new()
{
Id = 1001,
Name = "业务数据1",
Amount = 100,
},
new()
{
Id = 1002,
Name = "业务数据2",
Amount = 1000,
},
};
}
public IEnumerable<MultiBusinessTable> SeedData()
{
return default;
}
public Task CustomizeSeedData(ISqlSugarClient db)
{
return Task.CompletedTask;
}
}

@ -1,36 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Models;
namespace Tiobon.Core.Common.Seed.SeedData;
public class MultiBusinessSubDataSeedData : IEntitySeedData<MultiBusinessSubTable>
{
public IEnumerable<MultiBusinessSubTable> InitSeedData()
{
return new List<MultiBusinessSubTable>()
{
new()
{
Id = 100,
MainId = 1001,
Memo = "子数据",
},
new()
{
Id = 1001,
MainId = 1001,
Memo = "子数据2",
},
};
}
public IEnumerable<MultiBusinessSubTable> SeedData()
{
return default;
}
public Task CustomizeSeedData(ISqlSugarClient db)
{
return Task.CompletedTask;
}
}

@ -1,68 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Models;
namespace Tiobon.Core.Common.Seed.SeedData;
public class SubBusinessDataSeedData : IEntitySeedData<SubLibraryBusinessTable>
{
public IEnumerable<SubLibraryBusinessTable> InitSeedData()
{
return default;
}
public IEnumerable<SubLibraryBusinessTable> SeedData()
{
return default;
}
public async Task CustomizeSeedData(ISqlSugarClient db)
{
//初始化分库数据
//只是用于测试
if (db.CurrentConnectionConfig.ConfigId == "Tenant_3")
{
if (!await db.Queryable<SubLibraryBusinessTable>().AnyAsync())
{
await db.Insertable<SubLibraryBusinessTable>(new List<SubLibraryBusinessTable>()
{
new()
{
Id = SnowFlakeSingle.Instance.NextId(),
Name = "王五业务数据1",
Amount = 100,
},
new()
{
Id = SnowFlakeSingle.Instance.NextId(),
Name = "王五业务数据2",
Amount = 1000,
},
}).ExecuteReturnSnowflakeIdListAsync();
}
}
else if (db.CurrentConnectionConfig.ConfigId == "Tenant_4")
{
if (!await db.Queryable<SubLibraryBusinessTable>().AnyAsync())
{
await db.Insertable<SubLibraryBusinessTable>(new List<SubLibraryBusinessTable>()
{
new()
{
Id = SnowFlakeSingle.Instance.NextId(),
Name = "赵六业务数据1",
Amount = 50,
},
new()
{
Id = SnowFlakeSingle.Instance.NextId(),
Name = "赵六业务数据2",
Amount = 60,
},
}).ExecuteReturnSnowflakeIdListAsync();
}
}
await Task.Delay(1);
}
}

@ -1,66 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model;
namespace Tiobon.Core.Common.Seed.SeedData;
/// <summary>
/// 租户 种子数据
/// </summary>
public class TenantSeedData : IEntitySeedData<SysTenant>
{
public IEnumerable<SysTenant> InitSeedData()
{
return new[]
{
new SysTenant()
{
Id = 1000001,
ConfigId = "Tenant_1",
Name = "张三",
TenantType = TenantTypeEnum.Id
},
new SysTenant()
{
Id = 1000002,
ConfigId = "Tenant_2",
Name = "李四",
TenantType = TenantTypeEnum.Id
},
new SysTenant()
{
Id = 1000003,
ConfigId = "Tenant_3",
Name = "王五",
TenantType = TenantTypeEnum.Db,
DbType = DbType.Sqlite,
Connection = $"DataSource=" + Path.Combine(Environment.CurrentDirectory, "WangWu.db"),
},
new SysTenant()
{
Id = 1000004,
ConfigId = "Tenant_4",
Name = "赵六",
TenantType = TenantTypeEnum.Db,
DbType = DbType.Sqlite,
Connection = $"DataSource=" + Path.Combine(Environment.CurrentDirectory, "ZhaoLiu.db"),
},
new SysTenant()
{
Id = 1000005,
ConfigId = "Tenant_5",
Name = "孙七",
TenantType = TenantTypeEnum.Tables,
},
};
}
public IEnumerable<SysTenant> SeedData()
{
return default;
}
public Task CustomizeSeedData(ISqlSugarClient db)
{
return Task.CompletedTask;
}
}

@ -1,77 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Models;
namespace Tiobon.Core.Common.Seed.SeedData;
public class UserInfoSeedData : IEntitySeedData<SysUserInfo>
{
public IEnumerable<SysUserInfo> InitSeedData()
{
return default;
}
public IEnumerable<SysUserInfo> SeedData()
{
return default;
}
public async Task CustomizeSeedData(ISqlSugarClient db)
{
var data = new List<SysUserInfo>()
{
new SysUserInfo()
{
Id = 10001,
LoginName = "zhangsan",
LoginPWD = "E10ADC3949BA59ABBE56E057F20F883E",
Name = "张三",
TenantId = 1000001, //租户Id
},
new SysUserInfo()
{
Id = 10002,
LoginName = "lisi",
LoginPWD = "E10ADC3949BA59ABBE56E057F20F883E",
Name = "李四",
TenantId = 1000002, //租户Id
},
new SysUserInfo()
{
Id = 10003,
LoginName = "wangwu",
LoginPWD = "E10ADC3949BA59ABBE56E057F20F883E",
Name = "王五",
TenantId = 1000003, //租户Id
},
new SysUserInfo()
{
Id = 10004,
LoginName = "zhaoliu",
LoginPWD = "E10ADC3949BA59ABBE56E057F20F883E",
Name = "赵六",
TenantId = 1000004, //租户Id
},
new SysUserInfo()
{
Id = 10005,
LoginName = "sunqi",
LoginPWD = "E10ADC3949BA59ABBE56E057F20F883E",
Name = "孙七",
TenantId = 1000005, //租户Id
},
};
var names = data.Select(s => s.LoginName).ToList();
names = await db.Queryable<SysUserInfo>()
.Where(s => names.Contains(s.LoginName))
.Select(s => s.LoginName).ToListAsync();
var sysUserInfos = data.Where(s => !names.Contains(s.LoginName)).ToList();
if (sysUserInfos.Any())
{
await db.Insertable<SysUserInfo>(sysUserInfos).ExecuteReturnIdentityAsync();
}
await Task.CompletedTask;
}
}

@ -1,4 +1,5 @@
using AutoMapper; using AutoMapper;
using Tiobon.Core.Model;
using Tiobon.Core.Model.Models; using Tiobon.Core.Model.Models;
using Tiobon.Core.Model.ViewModels; using Tiobon.Core.Model.ViewModels;

@ -1,8 +1,7 @@
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Tiobon.Core.Common; using Tiobon.Core.Seed;
using Tiobon.Core.Common.Seed;
namespace Tiobon.Core.Extensions; namespace Tiobon.Core.Extensions;

@ -1,5 +1,5 @@
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Tiobon.Core.Common.Seed; using Tiobon.Core.Seed;
namespace Tiobon.Core.Extensions; namespace Tiobon.Core.Extensions;

@ -3,7 +3,7 @@ using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using System; using System;
using Tiobon.Core.Common.Seed; using Tiobon.Core.Seed;
using Tiobon.Core.DataAccess; using Tiobon.Core.DataAccess;
using Tiobon.Core.DB; using Tiobon.Core.DB;
using Tiobon.Core.DB.Dapper.Extensions; using Tiobon.Core.DB.Dapper.Extensions;

@ -1,18 +0,0 @@
namespace Tiobon.Core.Model;
/// <summary>
/// 用户信息表
/// </summary>
public class SysUserInfoRoot<Tkey> where Tkey : IEquatable<Tkey>
{
/// <summary>
/// Id
/// 泛型主键Tkey
/// </summary>
[SugarColumn(IsNullable = false, IsPrimaryKey = true)]
public Tkey Id { get; set; }
[SugarColumn(IsIgnore = true)]
public List<Tkey> RIDs { get; set; }
}

@ -1,26 +0,0 @@
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 业务数据 <br/>
/// 多租户 (Id 隔离)
/// </summary>
public class BusinessTable : BaseEntity, ITenantEntity
{
/// <summary>
/// 无需手动赋值
/// </summary>
public long TenantId { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 金额
/// </summary>
public decimal Amount { get; set; }
}

@ -1,11 +0,0 @@
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 多租户-多表方案 业务表 子表 <br/>
/// </summary>
[MultiTenant(TenantTypeEnum.Tables)]
public class MultiBusinessSubTable : BaseEntity
{
public long MainId { get; set; }
public string Memo { get; set; }
}

@ -1,21 +0,0 @@
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 多租户-多表方案 业务表 <br/>
/// </summary>
[MultiTenant(TenantTypeEnum.Tables)]
public class MultiBusinessTable : BaseEntity
{
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 金额
/// </summary>
public decimal Amount { get; set; }
[Navigate(NavigateType.OneToMany, nameof(MultiBusinessSubTable.MainId))]
public List<MultiBusinessSubTable> Child { get; set; }
}

@ -1,19 +0,0 @@
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 多租户-多库方案 业务表 <br/>
/// 公共库无需标记[MultiTenant]特性
/// </summary>
[MultiTenant]
public class SubLibraryBusinessTable : BaseEntity
{
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 金额
/// </summary>
public decimal Amount { get; set; }
}

@ -1,139 +0,0 @@
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 用户信息表
/// </summary>
//[SugarTable("SysUserInfo")]
[SugarTable("SysUserInfo", "用户表")] //('数据库表名','数据库表备注')
public class SysUserInfo : SysUserInfoRoot<long>
{
public SysUserInfo()
{
}
public SysUserInfo(string loginName, string loginPWD)
{
LoginName = loginName;
LoginPWD = loginPWD;
RealName = LoginName;
Status = 0;
CreateTime = DateTime.Now;
UpdateTime = DateTime.Now;
LastErrorTime = DateTime.Now;
ErrorCount = 0;
Name = "";
}
/// <summary>
/// 登录账号
/// </summary>
[SugarColumn(Length = 200, IsNullable = true, ColumnDescription = "登录账号")]
//:eg model 根据sqlsugar的完整定义可以如下定义,ColumnDescription可定义表字段备注
//[SugarColumn(IsNullable = false, ColumnDescription = "登录账号", IsPrimaryKey = false, IsIdentity = false, Length = 50)]
//ColumnDescription 表字段备注, 已在MSSQL测试,配合 [SugarTable("SysUserInfo", "用户表")]//('数据库表名','数据库表备注')
//可以完整生成 表备注和各个字段的中文备注
//2022/10/11
//测试mssql 发现 不写ColumnDescription,写好注释在mssql下也能生成表字段备注
public string LoginName { get; set; }
/// <summary>
/// 登录密码
/// </summary>
[SugarColumn(Length = 200, IsNullable = true)]
public string LoginPWD { get; set; }
/// <summary>
/// 真实姓名
/// </summary>
[SugarColumn(Length = 200, IsNullable = true)]
public string RealName { get; set; }
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; }
/// <summary>
/// 部门
/// </summary>
[SugarColumn(IsNullable = true)]
public long DepartmentId { get; set; } = -1;
/// <summary>
/// 备注
/// </summary>
[SugarColumn(Length = 2000, IsNullable = true)]
public string Remark { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime { get; set; } = DateTime.Now;
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdateTime { get; set; } = DateTime.Now;
/// <summary>
/// 关键业务修改时间
/// </summary>
public DateTime CriticalModifyTime { get; set; } = DateTime.Now;
/// <summary>
///最后异常时间
/// </summary>
public DateTime LastErrorTime { get; set; } = DateTime.Now;
/// <summary>
///错误次数
/// </summary>
public int ErrorCount { get; set; }
/// <summary>
/// 登录账号
/// </summary>
[SugarColumn(Length = 200, IsNullable = true)]
public string Name { get; set; }
// 性别
[SugarColumn(IsNullable = true)]
public int Sex { get; set; } = 0;
// 年龄
[SugarColumn(IsNullable = true)]
public int Age { get; set; }
// 生日
[SugarColumn(IsNullable = true)]
public DateTime Birth { get; set; } = DateTime.Now;
// 地址
[SugarColumn(Length = 200, IsNullable = true)]
public string Address { get; set; }
[SugarColumn(DefaultValue = "1")]
public bool Enable { get; set; } = true;
[SugarColumn(IsNullable = true)]
public bool IsDeleted { get; set; }
/// <summary>
/// 租户Id
/// </summary>
[SugarColumn(IsNullable = false, DefaultValue = "0")]
public long TenantId { get; set; }
[Navigate(NavigateType.OneToOne, nameof(TenantId))]
public SysTenant Tenant { get; set; }
[SugarColumn(IsIgnore = true)]
public List<string> RoleNames { get; set; }
[SugarColumn(IsIgnore = true)]
public List<long> Dids { get; set; }
[SugarColumn(IsIgnore = true)]
public string DepartmentName { get; set; }
}

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
namespace Tiobon.Core.Model.ViewModels
{
public class SysUserInfoDtoRoot<Tkey> where Tkey : IEquatable<Tkey>
{
public Tkey uID { get; set; }
public List<Tkey> RIDs { get; set; }
}
}

@ -1,24 +0,0 @@
namespace Tiobon.Core.Model.ViewModels;
public class SysUserInfoDto : SysUserInfoDtoRoot<long>
{
public string uLoginName { get; set; }
public string uLoginPWD { get; set; }
public string uRealName { get; set; }
public int uStatus { get; set; }
public long DepartmentId { get; set; }
public string uRemark { get; set; }
public System.DateTime uCreateTime { get; set; } = DateTime.Now;
public System.DateTime uUpdateTime { get; set; } = DateTime.Now;
public DateTime uLastErrTime { get; set; } = DateTime.Now;
public int uErrorCount { get; set; }
public string name { get; set; }
public int sex { get; set; } = 0;
public int age { get; set; }
public DateTime birth { get; set; } = DateTime.Now;
public string addr { get; set; }
public bool tdIsDelete { get; set; }
public List<string> RoleNames { get; set; }
public List<long> Dids { get; set; }
public string DepartmentName { get; set; }
}

@ -1,6 +1,5 @@
using Tiobon.Core.Common.DB; using Tiobon.Core.Repository.UnitOfWorks;
using Tiobon.Core.Common.Seed; using Tiobon.Core.Seed;
using Tiobon.Core.Repository.UnitOfWorks;
namespace Tiobon.Core.Services; namespace Tiobon.Core.Services;

@ -2,6 +2,7 @@
using SqlSugar; using SqlSugar;
using Tiobon.Core.Helper; using Tiobon.Core.Helper;
using Tiobon.Core.IRepository.Base; using Tiobon.Core.IRepository.Base;
using Tiobon.Core.Model;
using Tiobon.Core.Model.Models; using Tiobon.Core.Model.Models;
using Xunit; using Xunit;
using Xunit.Abstractions; using Xunit.Abstractions;

@ -12,7 +12,7 @@ using System.Security.Claims;
using System.Text; using System.Text;
using Tiobon.Core.AuthHelper; using Tiobon.Core.AuthHelper;
using Tiobon.Core.AppConfig; using Tiobon.Core.AppConfig;
using Tiobon.Core.Common.Seed; using Tiobon.Core.Seed;
using Tiobon.Core.DB; using Tiobon.Core.DB;
using Tiobon.Core.Extensions; using Tiobon.Core.Extensions;
using Tiobon.Core.IRepository.Base; using Tiobon.Core.IRepository.Base;

@ -39070,133 +39070,6 @@
修改时间 修改时间
</summary> </summary>
</member> </member>
<member name="T:Tiobon.Core.Model.Models.SysUserInfo">
<summary>
用户信息表
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.LoginName">
<summary>
登录账号
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.LoginPWD">
<summary>
登录密码
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.RealName">
<summary>
真实姓名
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.Status">
<summary>
状态
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.DepartmentId">
<summary>
部门
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.Remark">
<summary>
备注
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.CreateTime">
<summary>
创建时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.UpdateTime">
<summary>
更新时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.CriticalModifyTime">
<summary>
关键业务修改时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.LastErrorTime">
<summary>
最后异常时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.ErrorCount">
<summary>
错误次数
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.Name">
<summary>
登录账号
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysUserInfo.TenantId">
<summary>
租户Id
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.BusinessTable">
<summary>
业务数据 <br/>
多租户 (Id 隔离)
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.BusinessTable.TenantId">
<summary>
无需手动赋值
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.BusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.BusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.MultiBusinessSubTable">
<summary>
多租户-多表方案 业务表 子表 <br/>
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.MultiBusinessTable">
<summary>
多租户-多表方案 业务表 <br/>
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.MultiBusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.MultiBusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.SubLibraryBusinessTable">
<summary>
多租户-多库方案 业务表 <br/>
公共库无需标记[MultiTenant]特性
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SubLibraryBusinessTable.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SubLibraryBusinessTable.Amount">
<summary>
金额
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.UserRole"> <member name="T:Tiobon.Core.Model.Models.UserRole">
<summary> <summary>
用户跟角色关联表 用户跟角色关联表
@ -42761,17 +42634,6 @@
api ID api ID
</summary> </summary>
</member> </member>
<member name="T:Tiobon.Core.Model.SysUserInfoRoot`1">
<summary>
用户信息表
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysUserInfoRoot`1.Id">
<summary>
Id
泛型主键Tkey
</summary>
</member>
<member name="T:Tiobon.Core.Model.UserRoleRoot`1"> <member name="T:Tiobon.Core.Model.UserRoleRoot`1">
<summary> <summary>
用户跟角色关联表 用户跟角色关联表

Loading…
Cancel
Save