/// <summary>
/// 生成JwtToken
/// </summary>
public static string CreateToken(Claim[] claims, HybridOptions options)
{
JwtOptions jwtOptions = options.Jwt;
string secret = jwtOptions.Secret;
if (secret == null)
{
throw new HybridException("创建JwtToken时Secret为空");
}
SecurityKey key = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secret));
SigningCredentials credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature);
DateTime now = DateTime.UtcNow;
double days = Math.Abs(jwtOptions.AccessExpireMins) > 0 ? Math.Abs(jwtOptions.AccessExpireMins) : 7;
DateTime expires = now.AddDays(days);
SecurityTokenDescriptor descriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Audience = jwtOptions.Audience,
Issuer = jwtOptions.Issuer,
SigningCredentials = credentials,
NotBefore = now,
IssuedAt = now,
Expires = expires
};
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
SecurityToken token = tokenHandler.CreateToken(descriptor);
return(tokenHandler.WriteToken(token));
}
public override void UseModule(IServiceProvider provider)
{
IHybridStartupConfiguration Configuration = provider.GetRequiredService <IHybridStartupConfiguration>();
HybridOptions Options = provider.GetRequiredService <IOptions <HybridOptions> >().Value;
Configuration.Localization.Sources.Add(
new DictionaryBasedLocalizationSource(
LocalizationConsts.HybridSourceName,
new XmlEmbeddedFileLocalizationDictionaryProvider(
typeof(QuartzOptions).GetAssembly(), "Hybrid.Localization.Sources.XmlSource"
)));
InitConfiguration(Configuration, Options);
}
/// <summary>
/// 初始化一个<see cref="HostHttpCrypto"/>类型的新实例
/// </summary>
public HostHttpCrypto(IServiceProvider provider)
{
_logger = provider.GetLogger(typeof(HostHttpCrypto));
HybridOptions options = provider.GetHybridOptions();
if (options?.HttpEncrypt?.IsEnabled == true)
{
HttpEncryptConfiguration httpEncrypt = options.HttpEncrypt;
_privateKey = httpEncrypt.HostPrivateKey;
if (string.IsNullOrEmpty(_privateKey))
{
throw new HybridException("配置文件中HttpEncrypt节点的HostPrivateKey不能为空");
}
}
}
/// <summary>
/// 获取实体上下文所属的数据库类型
/// </summary>
public static DatabaseType GetDatabaseType(this IDbContext dbContext)
{
if (!(dbContext is DbContext context))
{
throw new HybridException($"参数dbContext类型为“{dbContext.GetType()}”，不能转换为 DbContext");
}
HybridOptions options = context.GetService <IOptions <HybridOptions> >()?.Value;
if (options != null)
{
return(options.DbContexts.First(m => m.Value.DbContextType == context.GetType()).Value.DatabaseType);
}
return(DatabaseType.SqlServer);
}
public override bool LazyLoadingProxiesEnabled()
{
if (_serviceProvider == null)
{
IConfiguration configuration = Singleton <IConfiguration> .Instance;
return(configuration["Hybrid:DbContexts:PostgreSql:LazyLoadingProxiesEnabled"].CastTo(false));
}
HybridOptions options = _serviceProvider.GetHybridOptions();
HybridDbContextOptions contextOptions = options.GetDbContextOptions(typeof(DefaultDbContext));
if (contextOptions == null)
{
throw new HybridException($"上下文“{typeof(DefaultDbContext)}”的配置信息不存在");
}
return(contextOptions.LazyLoadingProxiesEnabled);
}
public override string GetConnectionString()
{
if (_serviceProvider == null)
{
IConfiguration configuration = Singleton <IConfiguration> .Instance;
string str = configuration["Hybrid:DbContexts:PostgreSql:ConnectionString"];
return(str);
}
HybridOptions options = _serviceProvider.GetHybridOptions();
HybridDbContextOptions contextOptions = options.GetDbContextOptions(typeof(DefaultDbContext));
if (contextOptions == null)
{
throw new HybridException($"上下文“{typeof(DefaultDbContext)}”的配置信息不存在");
}
return(contextOptions.ConnectionString);
}
/// <summary>
/// 将基于Hybrid数据上下文基类<see cref="DbContextBase"/>上下文类型添加到服务集合中
/// </summary>
/// <typeparam name="TDbContext">基于Hybrid数据上下文基类<see cref="DbContextBase"/>上下文类型</typeparam>
/// <param name="services">依赖注入服务集合</param>
/// <param name="optionsAction">数据库选项创建配置，将在内置配置后运行</param>
/// <returns>依赖注入服务集合</returns>
public static IServiceCollection AddHybridDbContext <TDbContext>(this IServiceCollection services, Action <IServiceProvider, DbContextOptionsBuilder> optionsAction = null) where TDbContext : DbContextBase
{
services.AddDbContext <TDbContext>((provider, builder) =>
{
Type dbContextType = typeof(TDbContext);
HybridOptions hybridOptions = provider.GetHybridOptions();
HybridDbContextOptions hybridDbContextOptions = hybridOptions?.GetDbContextOptions(dbContextType);
if (hybridDbContextOptions == null)
{
throw new HybridException($"无法找到数据上下文“{dbContextType.DisplayName()}”的配置信息");
}
//启用延迟加载
if (hybridDbContextOptions.LazyLoadingProxiesEnabled)
{
builder = builder.UseLazyLoadingProxies();
}
DatabaseType databaseType = hybridDbContextOptions.DatabaseType;
//处理数据库驱动差异处理
IDbContextOptionsBuilderDriveHandler driveHandler = provider.GetServices <IDbContextOptionsBuilderDriveHandler>()
.FirstOrDefault(m => m.Type == databaseType);
if (driveHandler == null)
{
throw new HybridException($"无法解析类型为“{databaseType}”的 {typeof(IDbContextOptionsBuilderDriveHandler).DisplayName()} 实例");
}
ScopedDictionary scopedDictionary = provider.GetService <ScopedDictionary>();
string key = $"DnConnection_{hybridDbContextOptions.ConnectionString}";
DbConnection existingDbConnection = scopedDictionary.GetValue <DbConnection>(key);
builder = driveHandler.Handle(builder, hybridDbContextOptions.ConnectionString, existingDbConnection);
//使用模型缓存
DbContextModelCache modelCache = provider.GetService <DbContextModelCache>();
IModel model = modelCache?.Get(dbContextType);
if (model != null)
{
builder = builder.UseModel(model);
}
//额外的选项
optionsAction?.Invoke(provider, builder);
});
return(services);
}
/// <summary>
/// 初始化一个<see cref="ClientHttpCrypto"/>类型的新实例
/// </summary>
public ClientHttpCrypto(IServiceProvider provider)
{
_logger = provider.GetLogger(typeof(ClientHttpCrypto));
HybridOptions options = provider.GetHybridOptions();
if (options?.HttpEncrypt?.IsEnabled == true)
{
HttpEncryptConfiguration httpEncrypt = options.HttpEncrypt;
string clientPublicKey = httpEncrypt.ClientPublicKey;
if (string.IsNullOrEmpty(clientPublicKey))
{
throw new HybridException("配置文件中HttpEncrypt节点的ClientPublicKey不能为空");
}
RsaHelper rsa = new RsaHelper();
_encryptor = new TransmissionEncryptor(rsa.PrivateKey, httpEncrypt.ClientPublicKey);
_publicKey = rsa.PublicKey;
}
}
/// <summary>
/// 初始化配置
/// </summary>
/// <param name="configuration"></param>
/// <param name="options"></param>
private void InitConfiguration(IHybridStartupConfiguration configuration, HybridOptions options)
{
// TODO: InitConfiguration
//Auditing
configuration.Auditing.IsEnabled = options.Auditing.IsEnabled;
configuration.Auditing.IsEnabledForAnonymousUsers = options.Auditing.IsEnabledForAnonymousUsers;
configuration.Auditing.SaveReturnValues = options.Auditing.SaveReturnValues;
var commonIgnoredTypes = new[]
{
typeof(Stream),
typeof(Expression)
};
foreach (var ignoredType in commonIgnoredTypes)
{
configuration.Auditing.IgnoredTypes.AddIfNotContains(ignoredType);
//Configuration.Validation.IgnoredTypes.AddIfNotContains(ignoredType);
}
//var validationIgnoredTypes = new[] { typeof(Type) };
//foreach (var ignoredType in validationIgnoredTypes)
//{
// Configuration.Validation.IgnoredTypes.AddIfNotContains(ignoredType);
//}
//Email
configuration.EmailSender.DisplayName = options.EmailSender.DisplayName;
configuration.EmailSender.Domain = options.EmailSender.Domain;
configuration.EmailSender.EnableSsl = options.EmailSender.EnableSsl;
configuration.EmailSender.Host = options.EmailSender.Host;
configuration.EmailSender.IsEnabled = options.EmailSender.IsEnabled;
configuration.EmailSender.Password = options.EmailSender.Password;
configuration.EmailSender.Port = options.EmailSender.Port;
configuration.EmailSender.UseDefaultCredentials = options.EmailSender.UseDefaultCredentials;
configuration.EmailSender.UserName = options.EmailSender.UserName;
//HttpEncrypt
configuration.HttpEncrypt.ClientPublicKey = options.HttpEncrypt.ClientPublicKey;
configuration.HttpEncrypt.HostPrivateKey = options.HttpEncrypt.HostPrivateKey;
configuration.HttpEncrypt.IsEnabled = options.HttpEncrypt.IsEnabled;
}
/// <summary>
/// 应用模块服务
/// </summary>
/// <param name="provider">服务提供者</param>
public override void UseModule(IServiceProvider provider)
{
HybridOptions options = provider.GetHybridOptions();
HybridDbContextOptions contextOptions = options.GetDbContextOptions(typeof(TDbContext));
if (contextOptions?.DatabaseType != DatabaseType)
{
return;
}
using (IServiceScope scope = provider.CreateScope())
{
TDbContext context = CreateDbContext(scope.ServiceProvider);
if (context != null && contextOptions.AutoMigrationEnabled)
{
context.CheckAndMigration();
DbContextModelCache modelCache = scope.ServiceProvider.GetService <DbContextModelCache>();
modelCache?.Set(context.GetType(), context.Model);
}
}
IsEnabled = true;
}
/// <summary>
/// 建立HealthChecks服务
/// </summary>
/// <param name="builder">HealthChecks服务创建者</param>
/// <param name="configuration">应用程序配置</param>
/// <returns></returns>
protected virtual IHealthChecksBuilder BuildHealthChecks(IHealthChecksBuilder builder, IConfiguration configuration)
{
IConfigurationSection section = configuration.GetSection("Hybrid");
HybridOptions options = section.Get <HybridOptions>();
//system
long providerMemory = configuration["Hybrid:HealthChecks:PrivateMemory"].CastTo(1000_000_000L);
long virtualMemorySize = configuration["Hybrid:HealthChecks:VirtualMemorySize"].CastTo(1000_000_000L);
long workingSet = configuration["Hybrid:HealthChecks:WorkingSet"].CastTo(1000_000_000L);
builder.AddPrivateMemoryHealthCheck(providerMemory); //最大私有内存
builder.AddVirtualMemorySizeHealthCheck(virtualMemorySize); //最大虚拟内存
builder.AddWorkingSetHealthCheck(workingSet); //最大工作内存
//数据库
foreach (var pair in options.DbContexts.OrderBy(m => m.Value.DatabaseType))
{
string connectionString = pair.Value.ConnectionString;
switch (pair.Value.DatabaseType)
{
case DatabaseType.SqlServer:
builder.AddSqlServer(connectionString, null, pair.Key);
break;
case DatabaseType.Sqlite:
builder.AddSqlite(connectionString, name: pair.Key);
break;
case DatabaseType.MySql:
builder.AddMySql(connectionString, pair.Key);
break;
case DatabaseType.PostgreSql:
builder.AddNpgSql(connectionString, name: pair.Key);
break;
case DatabaseType.Oracle:
builder.AddOracle(connectionString, name: pair.Key);
break;
default:
throw new ArgumentOutOfRangeException($"HybridOptions中 {pair.Value.DatabaseType} 不受支持");
}
}
//SMTP
if (options.EmailSender != null)
{
var smtp = options.EmailSender;
builder.AddSmtpHealthCheck(smtpOptions =>
{
smtpOptions.Host = smtp.Host;
smtpOptions.LoginWith(smtp.UserName, smtp.Password);
});
}
//Redis
if (options.Redis != null && options.Redis.IsEnabled)
{
var redis = options.Redis;
builder.AddRedis(redis.Configuration);
}
//Hangfire
if (configuration["Hybrid:Hangfire:Enabled"].CastTo(false))
{
builder.AddHangfire(hangfireOptions =>
{
hangfireOptions.MinimumAvailableServers = 1;
});
}
return(builder);
}
