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

master
xiaochanghai 2 weeks ago
parent b327491715
commit bb28ad8ba9
  1. BIN
      Lib/Tiobon.Core.Base.dll
  2. BIN
      Lib/Tiobon.Core.dll
  3. 165
      Lib/Tiobon.Core.xml
  4. 1
      Tiobon.Core.Api/Controllers/Systems/DynamicCodeFirstController.cs
  5. 23
      Tiobon.Core.Common/DB/Aop/SqlSugarReuse.cs
  6. 180
      Tiobon.Core.Common/DB/Aop/SqlsugarAop.cs
  7. 43
      Tiobon.Core.Common/DB/AppSecretConfig.cs
  8. 51
      Tiobon.Core.Common/DB/EntityUtility.cs
  9. 13
      Tiobon.Core.Common/DB/Extension/DbEntityException.cs
  10. 44
      Tiobon.Core.Common/DB/Extension/DynamicBuildException.cs
  11. 46
      Tiobon.Core.Common/DB/RepositorySetting.cs
  12. 99
      Tiobon.Core.Common/DB/TenantUtil.cs
  13. 1
      Tiobon.Core.Common/Seed/DBSeed.cs
  14. 3
      Tiobon.Core.Common/Seed/SeedData/TenantSeedData.cs
  15. 4
      Tiobon.Core.Common/Tiobon.Core.Common.csproj
  16. 2
      Tiobon.Core.Extensions/Authorizations/Helpers/JwtHelper.cs
  17. 2
      Tiobon.Core.Extensions/ServiceExtensions/Authentication_JWTSetup.cs
  18. 2
      Tiobon.Core.Extensions/ServiceExtensions/AuthorizationSetup.cs
  19. 3
      Tiobon.Core.Extensions/ServiceExtensions/SqlsugarSetup.cs
  20. 78
      Tiobon.Core.Model/Models/RootTkey/BaseEntity.cs
  21. 11
      Tiobon.Core.Model/Models/RootTkey/RootEntityTkey.cs
  22. 67
      Tiobon.Core.Model/Models/SysTenant.cs
  23. 3
      Tiobon.Core.Model/Models/Tenant/BusinessTable.cs
  24. 5
      Tiobon.Core.Model/Models/Tenant/MultiBusinessSubTable.cs
  25. 5
      Tiobon.Core.Model/Models/Tenant/MultiBusinessTable.cs
  26. 5
      Tiobon.Core.Model/Models/Tenant/SubLibraryBusinessTable.cs
  27. 13
      Tiobon.Core.Model/Tenants/ITenantEntity.cs
  28. 22
      Tiobon.Core.Model/Tenants/MultiTenantAttribute.cs
  29. 27
      Tiobon.Core.Model/Tenants/TenantTypeEnum.cs
  30. 2
      Tiobon.Core.Tests/DependencyInjection/DI_Test.cs
  31. 154
      Tiobon.Core/Tiobon.Core.Model.xml

Binary file not shown.

Binary file not shown.

@ -1077,6 +1077,17 @@
以嵌套事务方式执行 以嵌套事务方式执行
</summary> </summary>
</member> </member>
<member name="M:Tiobon.Core.DB.RepositorySetting.SetDeletedEntityFilter(SqlSugar.SqlSugarScopeProvider)">
<summary>
配置实体软删除过滤器<br/>
统一过滤 软删除 无需自己写条件
</summary>
</member>
<member name="M:Tiobon.Core.DB.RepositorySetting.SetTenantEntityFilter(SqlSugar.SqlSugarScopeProvider)">
<summary>
配置租户
</summary>
</member>
<member name="T:Tiobon.Core.DbInsert"> <member name="T:Tiobon.Core.DbInsert">
<summary> <summary>
Sql插入类 Sql插入类
@ -1258,6 +1269,26 @@
S盒 S盒
</summary> </summary>
</member> </member>
<member name="T:Tiobon.Core.TenantTypeEnum">
<summary>
租户隔离方案
</summary>
</member>
<member name="F:Tiobon.Core.TenantTypeEnum.Id">
<summary>
Id隔离
</summary>
</member>
<member name="F:Tiobon.Core.TenantTypeEnum.Db">
<summary>
库隔离
</summary>
</member>
<member name="F:Tiobon.Core.TenantTypeEnum.Tables">
<summary>
表隔离
</summary>
</member>
<member name="M:Tiobon.Core.Extensions.Extention.BuildExtendSelectExpre``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})"> <member name="M:Tiobon.Core.Extensions.Extention.BuildExtendSelectExpre``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})">
<summary> <summary>
组合继承属性选择表达式树,无拓展参数 组合继承属性选择表达式树,无拓展参数
@ -3082,6 +3113,60 @@
Body参数 Body参数
</summary> </summary>
</member> </member>
<member name="P:Tiobon.Core.Model.BaseEntity.Enabled">
<summary>
状态 <br/>
中立字段,某些表可使用某些表不使用
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.IsDeleted">
<summary>
中立字段,某些表可使用某些表不使用 <br/>
逻辑上的删除,非物理删除 <br/>
例如:单据删除并非直接删除
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.IsInternal">
<summary>
中立字段 <br/>
是否内置数据
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.CreateId">
<summary>
创建ID
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.CreateBy">
<summary>
创建者
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.CreateTime">
<summary>
创建时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.ModifyId">
<summary>
修改ID
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.ModifyBy">
<summary>
更新者
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.ModifyTime">
<summary>
修改日期
</summary>
</member>
<member name="P:Tiobon.Core.Model.BaseEntity.Version">
<summary>
数据版本
</summary>
</member>
<member name="P:Tiobon.Core.Model.Entity.BasePoco.Id"> <member name="P:Tiobon.Core.Model.Entity.BasePoco.Id">
<summary> <summary>
表主键 表主键
@ -3301,6 +3386,86 @@
返回信息 返回信息
</summary> </summary>
</member> </member>
<member name="P:Tiobon.Core.Model.RootEntityTkey`1.Id">
<summary>
ID
泛型主键Tkey
</summary>
</member>
<member name="T:Tiobon.Core.Model.Tenants.ITenantEntity">
<summary>
租户模型接口
</summary>
</member>
<member name="P:Tiobon.Core.Model.Tenants.ITenantEntity.TenantId">
<summary>
租户Id
</summary>
</member>
<member name="T:Tiobon.Core.Model.MultiTenantAttribute">
<summary>
标识 多租户 的业务表 <br/>
默认设置是多库 <br/>
公共表无需区分 直接使用主库 各自业务在各自库中 <br/>
</summary>
</member>
<member name="T:Tiobon.Core.Model.SysTenant">
<summary>
系统租户表 <br/>
根据TenantType 分为两种方案: <br/>
1.按租户字段区分<br/>
2.按租户分库<br/>
<br/>
注意:<br/>
使用租户Id方案,无需配置分库的连接
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.TenantType">
<summary>
租户类型
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.ConfigId">
<summary>
数据库/租户标识 不可重复<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.Host">
<summary>
主机<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.DbType">
<summary>
数据库类型<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.Connection">
<summary>
数据库连接<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.Status">
<summary>
状态
</summary>
</member>
<member name="P:Tiobon.Core.Model.SysTenant.Remark">
<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>

@ -1,6 +1,5 @@
using SqlSugar; using SqlSugar;
using Tiobon.Core.Common.DB.Extension; using Tiobon.Core.Common.DB.Extension;
using Tiobon.Core.Model.Models.RootTkey;
namespace Tiobon.Core.Api.Controllers.Systems; namespace Tiobon.Core.Api.Controllers.Systems;

@ -1,23 +0,0 @@
using SqlSugar;
using Tiobon.Core.DB;
namespace Tiobon.Core.Common.DB.Aop;
public class SqlSugarReuse
{
public static void AutoChangeAvailableConnect(SqlSugarClient db)
{
if (db == null) return;
if (db.Ado.IsValidConnection()) return;
if (!BaseDBConfig.ReuseConfigs.Any()) return;
foreach (var connectionConfig in BaseDBConfig.ReuseConfigs)
{
var config = db.CurrentConnectionConfig.ConfigId;
db.ChangeDatabase(connectionConfig.ConfigId);
//移除旧的连接,只会在本次上下文移除,因为主库已经故障会导致多库事务无法使用
db.RemoveConnection(config);
if (db.Ado.IsValidConnection()) return;
}
}
}

@ -1,180 +0,0 @@
using Serilog;
using SqlSugar;
using StackExchange.Profiling;
using Tiobon.Core.LogHelper;
using Tiobon.Core.Model.Entity;
using Tiobon.Core.Model.Models.RootTkey;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Common.DB.Aop;
public static class SqlSugarAop
{
public static void OnLogExecuting(ISqlSugarClient sqlSugarScopeProvider, string user, string table, string operate, string sql, SugarParameter[] p, ConnectionConfig config)
{
try
{
MiniProfiler.Current.CustomTiming($"ConnId:[{config.ConfigId}] SQL:", GetParas(p) + "【SQL语句】:" + sql);
if (!AppSettings.app(new string[] { "AppSettings", "SqlAOP", "Enabled" }).ObjToBool()) return;
if (AppSettings.app(new string[] { "AppSettings", "SqlAOP", "LogToConsole", "Enabled" }).ObjToBool() ||
AppSettings.app(new string[] { "AppSettings", "SqlAOP", "LogToFile", "Enabled" }).ObjToBool() ||
AppSettings.app(new string[] { "AppSettings", "SqlAOP", "LogToDB", "Enabled" }).ObjToBool())
{
using (LogContextExtension.Create.SqlAopPushProperty(sqlSugarScopeProvider))
{
Log.Information("------------------ \r\n User:[{User}] Table:[{Table}] Operate:[{Operate}] ConnId:[{ConnId}]【SQL语句】: \r\n {Sql}",
user, table, operate, config.ConfigId, UtilMethods.GetNativeSql(sql, p));
}
}
}
catch (Exception e)
{
Log.Error("Error occured OnLogExcuting:" + e);
}
}
public static void DataExecuting(object oldValue, DataFilterModel entityInfo)
{
if (entityInfo.EntityValue is BasePoco rootEntity)
if (rootEntity.Id == 0)
rootEntity.Id = SnowFlakeSingle.Instance.NextId();
if (entityInfo.EntityValue is BaseEntity baseEntity)
{
// 新增操作
if (entityInfo.OperationType == DataFilterType.InsertByObject)
if (baseEntity.CreateTime == DateTime.MinValue)
baseEntity.CreateTime = DateTime.Now;
if (entityInfo.OperationType == DataFilterType.UpdateByObject)
baseEntity.ModifyTime = DateTime.Now;
if (App.User?.ID > 0)
{
if (baseEntity is ITenantEntity tenant && App.User.TenantId > 0)
{
if (tenant.TenantId == 0)
tenant.TenantId = App.User.TenantId;
}
switch (entityInfo.OperationType)
{
case DataFilterType.UpdateByObject:
baseEntity.ModifyId = App.User.ID;
baseEntity.ModifyBy = App.User.Name;
break;
case DataFilterType.InsertByObject:
if (baseEntity.CreateBy.IsNullOrEmpty() || baseEntity.CreateId is null or <= 0)
{
baseEntity.CreateId = App.User.ID;
baseEntity.CreateBy = App.User.Name;
}
break;
}
}
}
else
{
//兼容以前的表
//这里要小心 在AOP里用反射 数据量多性能就会有问题
//要么都统一使用基类
//要么考虑老的表没必要兼容老的表
//
var getType = entityInfo.EntityValue.GetType();
int userId = Convert.ToInt32(App.User.ID);
switch (entityInfo.OperationType)
{
case DataFilterType.InsertByObject:
var dyCreateBy = getType.GetProperty("CreateBy");
var dyCreateTime = getType.GetProperty("CreateTime");
BasePoco ent = entityInfo.EntityValue as BasePoco;
if (ent != null && ent.Id == 0)
ent.Id = SnowFlakeSingle.Instance.NextId();
if (App.User?.ID > 0 && dyCreateBy != null && dyCreateBy.GetValue(entityInfo.EntityValue) == null)
{
try
{
dyCreateBy.SetValue(entityInfo.EntityValue, Convert.ToInt32(App.User.ID));
}
catch (Exception)
{
dyCreateBy.SetValue(entityInfo.EntityValue, App.User.ID);
}
}
if ((dyCreateTime != null && dyCreateTime.GetValue(entityInfo.EntityValue) is null) || (dyCreateTime != null && dyCreateTime.GetValue(entityInfo.EntityValue) != null && (DateTime)dyCreateTime.GetValue(entityInfo.EntityValue) == DateTime.MinValue))
dyCreateTime.SetValue(entityInfo.EntityValue, DateTime.Now);
break;
case DataFilterType.UpdateByObject:
if (entityInfo.PropertyName == "UpdateBy")
{
var UpdateBy = getType.GetProperty("UpdateBy");
if (App.User?.ID > 0 && UpdateBy != null)
{
try
{
UpdateBy.SetValue(entityInfo.EntityValue, Convert.ToInt32(App.User.ID));
}
catch (Exception)
{
UpdateBy.SetValue(entityInfo.EntityValue, App.User.ID);
}
}
}
else if (entityInfo.PropertyName == "UpdateTime")
{
var dyModifyTime = getType.GetProperty("UpdateTime");
if (dyModifyTime != null)
dyModifyTime.SetValue(entityInfo.EntityValue, DateTime.Now);
}
//else if (entityInfo.PropertyName == "UpdateTime")
//{
// HttpRequest request = UserContext.Context.Request;
// var api = request.Path.ObjToString().TrimEnd('/').ToLower();
//}
//else if (entityInfo.PropertyName == "UpdateTime")
//{
// var dyModifyTime = getType.GetProperty("UpdateTime");
// if (dyModifyTime != null)
// dyModifyTime.SetValue(entityInfo.EntityValue, DateTime.Now);
//}
break;
}
}
}
private static string GetWholeSql(SugarParameter[] paramArr, string sql)
{
foreach (var param in paramArr)
{
sql = sql.Replace(param.ParameterName, $@"'{param.Value.ObjToString()}'");
}
return sql;
}
private static string GetParas(SugarParameter[] pars)
{
string key = "【SQL参数】:";
foreach (var param in pars)
{
key += $"{param.ParameterName}:{param.Value}\n";
}
return key;
}
}

@ -1,43 +0,0 @@
namespace Tiobon.Core.Common.AppConfig;
public class AppSecretConfig
{
private static string Audience_Secret = AppSettings.app(new string[] { "Audience", "Secret" });
private static string Audience_Secret_File = AppSettings.app(new string[] { "Audience", "SecretFile" });
public static string Audience_Secret_String => InitAudience_Secret();
private static string InitAudience_Secret()
{
var securityString = DifDBConnOfSecurity(Audience_Secret_File);
if (!string.IsNullOrEmpty(Audience_Secret_File)&& !string.IsNullOrEmpty(securityString))
{
return securityString;
}
else
{
return Audience_Secret;
}
}
private static string DifDBConnOfSecurity(params string[] conn)
{
foreach (var item in conn)
{
try
{
if (File.Exists(item))
{
return File.ReadAllText(item).Trim();
}
}
catch (System.Exception) { }
}
return "";
}
}

@ -1,51 +0,0 @@
using SqlSugar;
using System.Diagnostics;
using System.Reflection;
using Tiobon.Core.Extensions;
using Tiobon.Core.DB;
using Tiobon.Core.Model;
namespace Tiobon.Core.Common.DB;
public class EntityUtility
{
private static readonly Lazy<Dictionary<string, List<Type>>> _tenantEntitys = new(() =>
{
Dictionary<string, List<Type>> dic = new Dictionary<string, List<Type>>();
var assembly = Assembly.Load("Tiobon.Core.Model");
//扫描 实体
foreach (var type in assembly.GetTypes().Where(s => s.IsClass && !s.IsAbstract))
{
var tenant = type.GetCustomAttribute<TenantAttribute>();
if (tenant != null)
{
dic.TryAdd(tenant.configId.ToString(), type);
continue;
}
if (type.IsSubclassOf(typeof(RootEntityTkey<>)))
{
dic.TryAdd(MainDb.CurrentDbConnId, type);
continue;
}
var table = type.GetCustomAttribute<SugarTable>();
if (table != null)
{
dic.TryAdd(MainDb.CurrentDbConnId, type);
continue;
}
Debug.Assert(type.Namespace != null, "type.Namespace != null");
if (type.Namespace.StartsWith("Tiobon.Core.Model.Models"))
{
dic.TryAdd(MainDb.CurrentDbConnId, type);
continue;
}
}
return dic;
});
public static Dictionary<string, List<Type>> TenantEntitys => _tenantEntitys.Value;
}

@ -1,13 +0,0 @@
using SqlSugar;
using System.Reflection;
namespace Tiobon.Core.Common.DB.Extension;
public static class DbEntityException
{
public static object GetEntityTenant(this Type type)
{
var tenant = type.GetCustomAttribute<TenantAttribute>();
return tenant?.configId;
}
}

@ -1,44 +0,0 @@
using SqlSugar;
using System.Reflection;
using System.Reflection.Emit;
namespace Tiobon.Core.Common.DB.Extension;
public static class DynamicBuildException
{
private static List<CustomAttributeBuilder> GetEntityAttr(this DynamicBuilder builder)
{
FieldInfo fieldInfo = builder.GetType().GetField("entityAttr", BindingFlags.Instance | BindingFlags.NonPublic);
List<CustomAttributeBuilder> entityAttr = (List<CustomAttributeBuilder>) fieldInfo.GetValue(builder);
return entityAttr;
}
private static CustomAttributeBuilder CreateIndex(SugarIndexAttribute indexAttribute)
{
Type type = typeof(SugarIndexAttribute);
var constructorTypes = new List<Type>() {typeof(string)};
for (int i = 0; i < indexAttribute.IndexFields.Count; i++)
{
constructorTypes.AddRange(new[] {typeof(string), typeof(OrderByType)});
}
constructorTypes.Add(typeof(bool));
var values = new List<object>() {indexAttribute.IndexName};
foreach (var indexField in indexAttribute.IndexFields)
{
values.AddRange(new object[] {indexField.Key, indexField.Value});
}
values.Add(indexAttribute.IsUnique);
return new CustomAttributeBuilder(type.GetConstructor(constructorTypes.ToArray())!, values.ToArray());
}
public static DynamicProperyBuilder CreateIndex(this DynamicProperyBuilder builder, SugarIndexAttribute indexAttribute)
{
var classBuilder = builder.baseBuilder;
var entityAttr = classBuilder.GetEntityAttr();
entityAttr.Add(CreateIndex(indexAttribute));
return builder;
}
}

@ -1,46 +0,0 @@
using SqlSugar;
using Tiobon.Core.Model.Entity;
using Tiobon.Core.Model.Models.RootTkey;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Common.DB;
public class RepositorySetting
{
private static readonly Lazy<IEnumerable<Type>> AllEntitys = new(() =>
{
return typeof(BaseEntity).Assembly
.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(typeof(BaseEntity)))
.Where(it => it.FullName != null && it.FullName.StartsWith("Tiobon.Core.Model.Models"));
});
public static IEnumerable<Type> Entitys => AllEntitys.Value;
/// <summary>
/// 配置实体软删除过滤器<br/>
/// 统一过滤 软删除 无需自己写条件
/// </summary>
public static void SetDeletedEntityFilter(SqlSugarScopeProvider db)
{
db.QueryFilter.AddTableFilter<IDeleteFilter>(it => it.IsDeleted == false);
db.QueryFilter.AddTableFilter<IBaseDeleteFilter>(it => it.IsEnable == 1);
}
/// <summary>
/// 配置租户
/// </summary>
public static void SetTenantEntityFilter(SqlSugarScopeProvider db)
{
if (App.User is not { ID: > 0, TenantId: > 0 })
{
return;
}
//多租户 单表
db.QueryFilter.AddTableFilter<ITenantEntity>(it => it.TenantId == App.User.TenantId || it.TenantId == 0);
//多租户 多表
db.SetTenantTable(App.User.TenantId.ToString());
}
}

@ -1,99 +0,0 @@
using SqlSugar;
using System.Reflection;
using Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Common.DB;
public static class TenantUtil
{
public static SysTenant DefaultTenantConfig(this SysTenant tenant)
{
tenant.DbType ??= DbType.Sqlite;
//如果没有配置连接
if (tenant.Connection.IsNullOrEmpty())
{
//此处默认配置 Sqlite 地址
//实际业务中 也会有运维、系统管理员等来维护
switch (tenant.DbType.Value)
{
case DbType.Sqlite:
tenant.Connection = $"DataSource={Path.Combine(Environment.CurrentDirectory, tenant.ConfigId)}.db";
break;
}
}
return tenant;
}
public static ConnectionConfig GetConnectionConfig(this SysTenant tenant)
{
if (tenant.DbType is null)
{
throw new ArgumentException("Tenant DbType Must");
}
return new ConnectionConfig()
{
ConfigId = tenant.ConfigId,
DbType = tenant.DbType.Value,
ConnectionString = tenant.Connection,
IsAutoCloseConnection = true,
MoreSettings = new ConnMoreSettings()
{
IsAutoRemoveDataCache = true,
SqlServerCodeFirstNvarchar = true,
},
};
}
public static List<Type> GetTenantEntityTypes(TenantTypeEnum? tenantType = null)
{
return RepositorySetting.Entitys
.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass)
.Where(s => IsTenantEntity(s, tenantType))
.ToList();
}
public static bool IsTenantEntity(this Type u, TenantTypeEnum? tenantType = null)
{
var mta = u.GetCustomAttribute<MultiTenantAttribute>();
if (mta is null)
{
return false;
}
if (tenantType != null)
{
if (mta.TenantType != tenantType)
{
return false;
}
}
return true;
}
public static string GetTenantTableName(this Type type, ISqlSugarClient db, string id)
{
var entityInfo = db.EntityMaintenance.GetEntityInfo(type);
return $@"{entityInfo.DbTableName}_{id}";
}
public static string GetTenantTableName(this Type type, ISqlSugarClient db, SysTenant tenant)
{
return GetTenantTableName(type, db, tenant.Id.ToString());
}
public static void SetTenantTable(this ISqlSugarClient db, string id)
{
var types = GetTenantEntityTypes(TenantTypeEnum.Tables);
foreach (var type in types)
{
db.MappingTables.Add(type.Name, type.GetTenantTableName(db, id));
}
}
}

@ -10,6 +10,7 @@ using Tiobon.Core.DB;
using Tiobon.Core.Helper; using Tiobon.Core.Helper;
using Tiobon.Core.Model.Models; using Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants; using Tiobon.Core.Model.Tenants;
using Tiobon.Core.Model;
namespace Tiobon.Core.Common.Seed; namespace Tiobon.Core.Common.Seed;

@ -1,6 +1,5 @@
using SqlSugar; using SqlSugar;
using Tiobon.Core.Model.Models; using Tiobon.Core.Model;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Common.Seed.SeedData; namespace Tiobon.Core.Common.Seed.SeedData;

@ -53,10 +53,6 @@
<ProjectReference Include="..\Tiobon.Core.Serilog.Es\Tiobon.Core.Serilog.Es.csproj" /> <ProjectReference Include="..\Tiobon.Core.Serilog.Es\Tiobon.Core.Serilog.Es.csproj" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<Folder Include="Static\" />
</ItemGroup>
<ItemGroup> <ItemGroup>
<Reference Include="Tiobon.Core"> <Reference Include="Tiobon.Core">
<HintPath>..\Lib\Tiobon.Core.dll</HintPath> <HintPath>..\Lib\Tiobon.Core.dll</HintPath>

@ -3,7 +3,7 @@ using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims; using System.Security.Claims;
using System.Text; using System.Text;
using Tiobon.Core.Common; using Tiobon.Core.Common;
using Tiobon.Core.Common.AppConfig; using Tiobon.Core.AppConfig;
namespace Tiobon.Core.AuthHelper.OverWrite; namespace Tiobon.Core.AuthHelper.OverWrite;

@ -6,7 +6,7 @@ using System.IdentityModel.Tokens.Jwt;
using System.Text; using System.Text;
using Tiobon.Core.AuthHelper; using Tiobon.Core.AuthHelper;
using Tiobon.Core.Common; using Tiobon.Core.Common;
using Tiobon.Core.Common.AppConfig; using Tiobon.Core.AppConfig;
namespace Tiobon.Core.Extensions; namespace Tiobon.Core.Extensions;

@ -6,7 +6,7 @@ using System.Security.Claims;
using System.Text; using System.Text;
using Tiobon.Core.AuthHelper; using Tiobon.Core.AuthHelper;
using Tiobon.Core.Common; using Tiobon.Core.Common;
using Tiobon.Core.Common.AppConfig; using Tiobon.Core.AppConfig;
namespace Tiobon.Core.Extensions; namespace Tiobon.Core.Extensions;

@ -3,10 +3,9 @@ using Microsoft.Extensions.DependencyInjection;
using SqlSugar; using SqlSugar;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using Tiobon.Core.Caches; using Tiobon.Core.Caches;
using Tiobon.Core.Common.DB;
using Tiobon.Core.Common.DB.Aop;
using Tiobon.Core.Const; using Tiobon.Core.Const;
using Tiobon.Core.DB; using Tiobon.Core.DB;
using Tiobon.Core.DB.Aop;
namespace Tiobon.Core.Extensions; namespace Tiobon.Core.Extensions;

@ -1,78 +0,0 @@
namespace Tiobon.Core.Model.Models.RootTkey;
[SugarIndex("index_{table}_Enabled", nameof(Enabled), OrderByType.Asc)]
[SugarIndex("index_{table}_IsDeleted", nameof(IsDeleted), OrderByType.Asc)]
public class BaseEntity : RootEntityTkey<long>, IDeleteFilter
{
#region 数据状态管理
/// <summary>
/// 状态 <br/>
/// 中立字段,某些表可使用某些表不使用
/// </summary>
public bool Enabled { get; set; } = true;
/// <summary>
/// 中立字段,某些表可使用某些表不使用 <br/>
/// 逻辑上的删除,非物理删除 <br/>
/// 例如:单据删除并非直接删除
/// </summary>
public bool IsDeleted { get; set; }
/// <summary>
/// 中立字段 <br/>
/// 是否内置数据
/// </summary>
public bool IsInternal { get; set; }
#endregion
#region 创建
/// <summary>
/// 创建ID
/// </summary>
[SugarColumn(IsNullable = true, IsOnlyIgnoreUpdate = true)]
public long? CreateId { get; set; }
/// <summary>
/// 创建者
/// </summary>
[SugarColumn(IsNullable = true, IsOnlyIgnoreUpdate = true)]
public string CreateBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
[SugarColumn(IsOnlyIgnoreUpdate = true)]
public DateTime CreateTime { get; set; } = DateTime.Now;
#endregion
#region 修改
/// <summary>
/// 修改ID
/// </summary>
[SugarColumn(IsNullable = true)]
public long? ModifyId { get; set; }
/// <summary>
/// 更新者
/// </summary>
[SugarColumn(IsNullable = true)]
public string ModifyBy { get; set; }
/// <summary>
/// 修改日期
/// </summary>
public DateTime? ModifyTime { get; set; } = DateTime.Now;
/// <summary>
/// 数据版本
/// </summary>
[SugarColumn(DefaultValue = "0", IsEnableUpdateVersionValidation = true)] //标识版本字段
public long Version { get; set; }
#endregion
}

@ -1,11 +0,0 @@
namespace Tiobon.Core.Model;
public class RootEntityTkey<Tkey> where Tkey : IEquatable<Tkey>
{
/// <summary>
/// ID
/// 泛型主键Tkey
/// </summary>
[SugarColumn(IsNullable = false, IsPrimaryKey = true)]
public Tkey Id { get; set; }
}

@ -1,67 +0,0 @@
using Tiobon.Core.Model.Tenants;
using SqlSugar;
namespace Tiobon.Core.Model.Models;
/// <summary>
/// 系统租户表 <br/>
/// 根据TenantType 分为两种方案: <br/>
/// 1.按租户字段区分<br/>
/// 2.按租户分库<br/>
///
/// <br/>
///
/// 注意:<br/>
/// 使用租户Id方案,无需配置分库的连接
/// </summary>
public class SysTenant : RootEntityTkey<long>
{
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 租户类型
/// </summary>
public TenantTypeEnum TenantType { get; set; }
/// <summary>
/// 数据库/租户标识 不可重复<br/>
/// 使用Id方案,可无需配置
/// </summary>
[SugarColumn(Length = 64)]
public string ConfigId { get; set; }
/// <summary>
/// 主机<br/>
/// 使用Id方案,可无需配置
/// </summary>
[SugarColumn(IsNullable = true)]
public string Host { get; set; }
/// <summary>
/// 数据库类型<br/>
/// 使用Id方案,可无需配置
/// </summary>
[SugarColumn(IsNullable = true)]
public SqlSugar.DbType? DbType { get; set; }
/// <summary>
/// 数据库连接<br/>
/// 使用Id方案,可无需配置
/// </summary>
[SugarColumn(IsNullable = true)]
public string Connection { get; set; }
/// <summary>
/// 状态
/// </summary>
public bool Status { get; set; } = true;
/// <summary>
/// 备注
/// </summary>
[SugarColumn(IsNullable = true)]
public string Remark { get; set; }
}

@ -1,5 +1,4 @@
using Tiobon.Core.Model.Models.RootTkey; using Tiobon.Core.Model.Tenants;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Model.Models; namespace Tiobon.Core.Model.Models;

@ -1,7 +1,4 @@
using Tiobon.Core.Model.Models.RootTkey; namespace Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Model.Models;
/// <summary> /// <summary>
/// 多租户-多表方案 业务表 子表 <br/> /// 多租户-多表方案 业务表 子表 <br/>

@ -1,7 +1,4 @@
using Tiobon.Core.Model.Models.RootTkey; namespace Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Model.Models;
/// <summary> /// <summary>
/// 多租户-多表方案 业务表 <br/> /// 多租户-多表方案 业务表 <br/>

@ -1,7 +1,4 @@
using Tiobon.Core.Model.Models.RootTkey; namespace Tiobon.Core.Model.Models;
using Tiobon.Core.Model.Tenants;
namespace Tiobon.Core.Model.Models;
/// <summary> /// <summary>
/// 多租户-多库方案 业务表 <br/> /// 多租户-多库方案 业务表 <br/>

@ -1,13 +0,0 @@
namespace Tiobon.Core.Model.Tenants;
/// <summary>
/// 租户模型接口
/// </summary>
public interface ITenantEntity
{
/// <summary>
/// 租户Id
/// </summary>
[SugarColumn(DefaultValue = "0")]
public long TenantId { get; set; }
}

@ -1,22 +0,0 @@
namespace Tiobon.Core.Model.Tenants;
/// <summary>
/// 标识 多租户 的业务表 <br/>
/// 默认设置是多库 <br/>
/// 公共表无需区分 直接使用主库 各自业务在各自库中 <br/>
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class MultiTenantAttribute : Attribute
{
public MultiTenantAttribute()
{
}
public MultiTenantAttribute(TenantTypeEnum tenantType)
{
TenantType = tenantType;
}
public TenantTypeEnum TenantType { get; set; } = TenantTypeEnum.Db;
}

@ -1,27 +0,0 @@
namespace Tiobon.Core.Model.Tenants;
/// <summary>
/// 租户隔离方案
/// </summary>
public enum TenantTypeEnum
{
None = 0,
/// <summary>
/// Id隔离
/// </summary>
[Description("Id隔离")]
Id = 1,
/// <summary>
/// 库隔离
/// </summary>
[Description("库隔离")]
Db = 2,
/// <summary>
/// 表隔离
/// </summary>
[Description("表隔离")]
Tables = 3,
}

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

@ -39070,117 +39070,6 @@
修改时间 修改时间
</summary> </summary>
</member> </member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.Enabled">
<summary>
状态 <br/>
中立字段,某些表可使用某些表不使用
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.IsDeleted">
<summary>
中立字段,某些表可使用某些表不使用 <br/>
逻辑上的删除,非物理删除 <br/>
例如:单据删除并非直接删除
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.IsInternal">
<summary>
中立字段 <br/>
是否内置数据
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.CreateId">
<summary>
创建ID
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.CreateBy">
<summary>
创建者
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.CreateTime">
<summary>
创建时间
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.ModifyId">
<summary>
修改ID
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.ModifyBy">
<summary>
更新者
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.ModifyTime">
<summary>
修改日期
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.RootTkey.BaseEntity.Version">
<summary>
数据版本
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.SysTenant">
<summary>
系统租户表 <br/>
根据TenantType 分为两种方案: <br/>
1.按租户字段区分<br/>
2.按租户分库<br/>
<br/>
注意:<br/>
使用租户Id方案,无需配置分库的连接
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.Name">
<summary>
名称
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.TenantType">
<summary>
租户类型
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.ConfigId">
<summary>
数据库/租户标识 不可重复<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.Host">
<summary>
主机<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.DbType">
<summary>
数据库类型<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.Connection">
<summary>
数据库连接<br/>
使用Id方案,可无需配置
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.Status">
<summary>
状态
</summary>
</member>
<member name="P:Tiobon.Core.Model.Models.SysTenant.Remark">
<summary>
备注
</summary>
</member>
<member name="T:Tiobon.Core.Model.Models.SysUserInfo"> <member name="T:Tiobon.Core.Model.Models.SysUserInfo">
<summary> <summary>
用户信息表 用户信息表
@ -42872,12 +42761,6 @@
api ID api ID
</summary> </summary>
</member> </member>
<member name="P:Tiobon.Core.Model.RootEntityTkey`1.Id">
<summary>
ID
泛型主键Tkey
</summary>
</member>
<member name="T:Tiobon.Core.Model.SysUserInfoRoot`1"> <member name="T:Tiobon.Core.Model.SysUserInfoRoot`1">
<summary> <summary>
用户信息表 用户信息表
@ -42967,43 +42850,6 @@
数据库读取类型 数据库读取类型
</summary> </summary>
</member> </member>
<member name="T:Tiobon.Core.Model.Tenants.ITenantEntity">
<summary>
租户模型接口
</summary>
</member>
<member name="P:Tiobon.Core.Model.Tenants.ITenantEntity.TenantId">
<summary>
租户Id
</summary>
</member>
<member name="T:Tiobon.Core.Model.Tenants.MultiTenantAttribute">
<summary>
标识 多租户 的业务表 <br/>
默认设置是多库 <br/>
公共表无需区分 直接使用主库 各自业务在各自库中 <br/>
</summary>
</member>
<member name="T:Tiobon.Core.Model.Tenants.TenantTypeEnum">
<summary>
租户隔离方案
</summary>
</member>
<member name="F:Tiobon.Core.Model.Tenants.TenantTypeEnum.Id">
<summary>
Id隔离
</summary>
</member>
<member name="F:Tiobon.Core.Model.Tenants.TenantTypeEnum.Db">
<summary>
库隔离
</summary>
</member>
<member name="F:Tiobon.Core.Model.Tenants.TenantTypeEnum.Tables">
<summary>
表隔离
</summary>
</member>
<member name="T:Tiobon.Core.Model.ViewModels.TiobonViewModels"> <member name="T:Tiobon.Core.Model.ViewModels.TiobonViewModels">
<summary> <summary>
博客信息展示类 博客信息展示类

Loading…
Cancel
Save