public static IBioWorldBuilder AddSwaggerDocs(this IBioWorldBuilder builder,
Func <ISwaggerOptionsBuilder, ISwaggerOptionsBuilder> buildOptions)
{
var options = buildOptions(new SwaggerOptionsBuilder()).Build();
return(builder.AddSwaggerDocs(options));
}
private static IBioWorldBuilder AddWebApiSwaggerDocs(this IBioWorldBuilder builder,
Action <IBioWorldBuilder> registerSwagger)
{
registerSwagger(builder);
builder.Services.AddSwaggerGen(c => c.DocumentFilter <WebApiDocumentFilter>());
return(builder);
}
public static IBioWorldBuilder AddConsul(this IBioWorldBuilder builder,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildOptions, HttpClientOptions httpClientOptions)
{
var options = buildOptions(new ConsulOptionsBuilder()).Build();
return(builder.AddConsul(options, httpClientOptions));
}
public static IBioWorldBuilder AddConsul(this IBioWorldBuilder builder, ConsulOptions options,
HttpClientOptions httpClientOptions)
{
builder.Services.AddSingleton(options);
if (!options.Enabled || !builder.TryRegister(RegistryName))
{
return(builder);
}
if (httpClientOptions.Type?.ToLowerInvariant() == "consul")
{
builder.Services.AddTransient <ConsulServiceDiscoveryMessageHandler>();
builder.Services.AddHttpClient <IConsulHttpClient, ConsulHttpClient>("consul-http")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
builder.RemoveHttpClient();
builder.Services.AddHttpClient <IHttpClient, ConsulHttpClient>("consul")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
}
builder.Services.AddTransient <IConsulServicesRegistry, ConsulServicesRegistry>();
var registration = builder.CreateConsulAgentRegistration(options);
if (registration is null)
{
return(builder);
}
builder.Services.AddSingleton(registration);
return(builder);
}
public static IBioWorldBuilder AddExceptionToMessageMapper <T>(this IBioWorldBuilder builder)
where T : class, IExceptionToMessageMapper
{
builder.Services.AddSingleton <IExceptionToMessageMapper, T>();
return(builder);
}
private static IBioWorldBuilder AddServiceClient <T>(this IBioWorldBuilder builder, string serviceName,
RestEaseOptions options, Action <IBioWorldBuilder> registerFabio)
where T : class
{
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
var clientName = typeof(T).ToString();
switch (options.LoadBalancer?.ToLowerInvariant())
{
case "consul":
builder.AddConsulHttpClient(clientName, serviceName);
break;
case "fabio":
builder.AddFabioHttpClient(clientName, serviceName);
break;
default:
ConfigureDefaultClient(builder.Services, clientName, serviceName, options);
break;
}
ConfigureForwarder <T>(builder.Services, clientName);
registerFabio(builder);
return(builder);
}
public static IBioWorldBuilder AddMongo(this IBioWorldBuilder builder, Func <IMongoDbOptionsBuilder,
IMongoDbOptionsBuilder> buildOptions, Type seederType = null, bool registerConventions = true)
{
var mongoOptions = buildOptions(new MongoDbOptionsBuilder()).Build();
return(builder.AddMongo(mongoOptions, seederType, registerConventions));
}
public static IBioWorldBuilder AddErrorHandler <T>(this IBioWorldBuilder builder)
where T : class, IExceptionToResponseMapper
{
builder.Services.AddTransient <ErrorHandlerMiddleware>();
builder.Services.AddSingleton <IExceptionToResponseMapper, T>();
return(builder);
}
public static IBioWorldBuilder AddSwaggerDocs(this IBioWorldBuilder builder, SwaggerOptions options)
{
if (!options.Enabled || !builder.TryRegister(RegisterName))
{
return(builder);
}
builder.Services.AddSingleton(options);
builder.Services.AddSwaggerGen(c =>
{
c.SwaggerDoc(options.Name, new OpenApiInfo()
{
Title = options.Title, Version = options.Version
});
if (options.IncludeSecurity)
{
c.AddSecurityDefinition("Bear", new OpenApiSecurityScheme()
{
Description =
"JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
}
});
return(builder);
}
public static TModel GetOptions <TModel>(this IBioWorldBuilder builder, string settingsSectionName)
where TModel : new()
{
using var serviceProvider = builder.Services.BuildServiceProvider();
var configuration = serviceProvider.GetService <IConfiguration>();
return(configuration.GetOptions <TModel>(settingsSectionName));
}
public static IBioWorldBuilder AddJaeger(this IBioWorldBuilder builder,
Func <IJaegerOptionsBuilder, IJaegerOptionsBuilder> buildOptions,
string sectionName = SectionName,
Action <IOpenTracingBuilder> openTracingBuilder = null)
{
var options = buildOptions(new JaegerOptionsBuilder()).Build();
return(builder.AddJaeger(options, sectionName, openTracingBuilder));
}
public static IBioWorldBuilder AddSecurity(this IBioWorldBuilder builder)
{
builder.Services
.AddSingleton <IEncryptor, Encryptor>()
.AddSingleton <IHasher, Hasher>()
.AddSingleton <ISigner, Signer>();
return(builder);
}
public static IBioWorldBuilder AddDistributedAccessTokenValidator(this IBioWorldBuilder builder)
{
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
builder.Services.AddSingleton <IAccessTokenService, DistributedAccessTokenService>();
return(builder);
}
public static IBioWorldBuilder AddFabio(this IBioWorldBuilder builder,
Func <IFabioOptionsBuilder, IFabioOptionsBuilder> buildOptions,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildConsulOptions,
HttpClientOptions httpClientOptions)
{
var fabioOptions = buildOptions(new FabioOptionsBuilder()).Build();
return(builder.AddFabio(fabioOptions, httpClientOptions,
b => b.AddConsul(buildConsulOptions, httpClientOptions)));
}
public static IBioWorldBuilder AddWebApiSwaggerDocs(this IBioWorldBuilder builder,
string sectionName = SectionName)
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
return(builder.AddWebApiSwaggerDocs(b => b.AddSwaggerDocs(sectionName)));
}
public static IBioWorldBuilder AddCommandHandlers(this IBioWorldBuilder builder)
{
builder.Services.Scan(s =>
s.FromAssemblies(AppDomain.CurrentDomain.GetAssemblies())
.AddClasses(c => c.AssignableTo(typeof(ICommandHandler <>))
.WithoutAttribute(typeof(DecoratorAttribute)))
.AsImplementedInterfaces()
.WithTransientLifetime());
return(builder);
}
public static IBioWorldBuilder AddRedis(this IBioWorldBuilder builder, string sectionName = SectionName)
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var options = builder.GetOptions <RedisOptions>(sectionName);
return(builder.AddRedis(options));
}
public static IBioWorldBuilder AddRabbitMq <TContext>(this IBioWorldBuilder builder,
Func <IRabbitMqOptionsBuilder, IRabbitMqOptionsBuilder> buildOptions,
Func <IRabbitMqPluginRegister, IRabbitMqPluginRegister> plugins = null,
Func <IRedisOptionsBuilder, IRedisOptionsBuilder> buildRedisOptions = null)
where TContext : class, new()
{
var options = buildOptions(new RabbitMqOptionsBuilder()).Build();
return(buildRedisOptions is null
? builder.AddRabbitMq <TContext>(options, plugins)
: builder.AddRabbitMq <TContext>(options, plugins, b => b.AddRedis(buildRedisOptions)));
}
public static IBioWorldBuilder AddMongo(this IBioWorldBuilder builder, string sectionName = SectionName,
Type seederType = null, bool registerConventions = true)
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var mongoOptions = builder.GetOptions <MongoDbOptions>(sectionName);
return(builder.AddMongo(mongoOptions, seederType, registerConventions));
}
public static IBioWorldBuilder AddJwt(this IBioWorldBuilder builder, string sectionName = SectionName,
Action <JwtBearerOptions> optionsFactory = null)
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var options = builder.GetOptions <JwtOptions>(sectionName);
return(builder.AddJwt(options, optionsFactory));
}
public static IBioWorldBuilder AddMongoRepository <TEntity, TIdentifiable>(this IBioWorldBuilder builder,
string collectionName)
where TEntity : IIdentifiable <TIdentifiable>
{
builder.Services.AddTransient <IMongoRepository <TEntity, TIdentifiable> >(sp =>
{
var database = sp.GetService <IMongoDatabase>();
return(new MongoRepository <TEntity, TIdentifiable>(database, collectionName));
});
return(builder);
}
public static IBioWorldBuilder AddServiceClient <T>(this IBioWorldBuilder builder, string serviceName,
Func <IRestEaseOptionsBuilder, IRestEaseOptionsBuilder> buildOptions,
Func <IConsulOptionsBuilder, IConsulOptionsBuilder> buildConsulOptions,
Func <IFabioOptionsBuilder, IFabioOptionsBuilder> buildFabioOptions,
HttpClientOptions httpClientOptions)
where T : class
{
var options = buildOptions(new RestEaseOptionsBuilder()).Build();
return(builder.AddServiceClient <T>(serviceName, options,
b => b.AddFabio(buildFabioOptions, buildConsulOptions, httpClientOptions)));
}
public static IBioWorldBuilder AddJaeger(this IBioWorldBuilder builder, string sectionName = SectionName,
Action <IOpenTracingBuilder> openTracingBuilder = null)
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var options = builder.GetOptions <JaegerOptions>(sectionName);
return(builder.AddJaeger(options, sectionName, openTracingBuilder));
}
public static IBioWorldBuilder AddConsul(this IBioWorldBuilder builder, string sectionName = SectionName,
string httpClientSectionName = "httpClient")
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var consulOptions = builder.GetOptions <ConsulOptions>(sectionName);
var httpClientOptions = builder.GetOptions <HttpClientOptions>(httpClientSectionName);
return(builder.AddConsul(consulOptions, httpClientOptions));
}
public static IBioWorldBuilder AddRabbitMq <TContext>(this IBioWorldBuilder builder, string sectionName = SectionName,
string redisSectionName = "redis", Func <IRabbitMqPluginRegister, IRabbitMqPluginRegister> plugins = null)
where TContext : class, new()
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var options = builder.GetOptions <RabbitMqOptions>(sectionName);
var redisOptions = builder.GetOptions <RedisOptions>(redisSectionName);
return(builder.AddRabbitMq <TContext>(options, plugins, b => b.AddRedis(redisOptions)));
}
public static IBioWorldBuilder AddServiceClient <T>(this IBioWorldBuilder builder, string serviceName,
string sectionName = SectionName, string consulSectionName = "consul", string fabioSectionName = "fabio",
string httpClientSectionName = "httpClient")
where T : class
{
if (string.IsNullOrWhiteSpace(sectionName))
{
sectionName = SectionName;
}
var restEaseOptions = builder.GetOptions <RestEaseOptions>(sectionName);
return(builder.AddServiceClient <T>(serviceName, restEaseOptions,
b => b.AddFabio(fabioSectionName, consulSectionName, httpClientSectionName)));
}
public static IBioWorldBuilder AddMongo(this IBioWorldBuilder builder, MongoDbOptions mongoOptions,
Type seederType = null, bool registerConventions = true)
{
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
if (mongoOptions.SetRandomDatabaseSuffix)
{
var suffix = $"{Guid.NewGuid():N}";
Console.WriteLine($"Setting a random MongoDB database suffix: '{suffix}'.");
mongoOptions.Database = $"{mongoOptions.Database}_{suffix}";
}
builder.Services.AddSingleton(mongoOptions);
builder.Services.AddSingleton <IMongoClient>(sp =>
{
var options = sp.GetService <MongoDbOptions>();
return(new MongoClient(options.ConnectionString));
});
builder.Services.AddTransient(sp =>
{
var options = sp.GetService <MongoDbOptions>();
var client = sp.GetService <IMongoClient>();
return(client.GetDatabase(options.Database));
});
builder.Services.AddTransient <IMongoDbInitializer, MongoDbInitializer>();
builder.Services.AddTransient <IMongoSessionFactory, MongoSessionFactory>();
if (seederType is null)
{
builder.Services.AddTransient <IMongoDbSeeder, MongoDbSeeder>();
}
else
{
builder.Services.AddTransient(typeof(IMongoDbSeeder), seederType);
}
builder.AddInitializer <IMongoDbInitializer>();
if (registerConventions && !_conventionsRegistered)
{
RegisterConventions();
}
return(builder);
}
public static IBioWorldBuilder AddCertificateAuthentication(this IBioWorldBuilder builder,
string sectionName = SectionName, Type permissionValidatorType = null)
{
var options = builder.GetOptions <SecurityOptions>(sectionName);
builder.Services.AddSingleton(options);
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
if (options.Certificate is null || !options.Certificate.Enabled)
{
return(builder);
}
if (permissionValidatorType is { })
private static IBioWorldBuilder AddJwt(this IBioWorldBuilder builder, JwtOptions options,
Action <JwtBearerOptions> optionsFactory = null)
{
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
builder.Services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton <IJwtHandler, JwtHandler>();
builder.Services.AddSingleton <IAccessTokenService, InMemoryAccessTokenService>();
builder.Services.AddTransient <AccessTokenValidatorMiddleware>();
if (options.AuthenticationDisabled)
{
builder.Services.AddSingleton <IPolicyEvaluator, DisabledAuthenticationPolicyEvaluator>();
}
var tokenValidationParameters = new TokenValidationParameters
{
RequireAudience = options.RequireAudience,
ValidIssuer = options.ValidIssuer,
ValidIssuers = options.ValidIssuers,
ValidateActor = options.ValidateActor,
ValidAudience = options.ValidAudience,
ValidAudiences = options.ValidAudiences,
ValidateAudience = options.ValidateAudience,
ValidateIssuer = options.ValidateIssuer,
ValidateLifetime = options.ValidateLifetime,
ValidateTokenReplay = options.ValidateTokenReplay,
ValidateIssuerSigningKey = options.ValidateIssuerSigningKey,
SaveSigninToken = options.SaveSigninToken,
RequireExpirationTime = options.RequireExpirationTime,
RequireSignedTokens = options.RequireSignedTokens,
ClockSkew = TimeSpan.Zero
};
if (!string.IsNullOrWhiteSpace(options.AuthenticationType))
{
tokenValidationParameters.AuthenticationType = options.AuthenticationType;
}
var hasCertificate = false;
if (options.Certificate is { })
public static IBioWorldBuilder AddRedis(this IBioWorldBuilder builder, RedisOptions options)
{
if (!builder.TryRegister(RegistryName))
{
return(builder);
}
builder.Services
.AddSingleton(options)
.AddSingleton <IConnectionMultiplexer>(sp => ConnectionMultiplexer.Connect(options.ConnectionString))
.AddTransient(sp => sp.GetRequiredService <IConnectionMultiplexer>().GetDatabase(options.Database))
.AddStackExchangeRedisCache(o =>
{
o.Configuration = options.ConnectionString;
o.InstanceName = options.Instance;
});
return(builder);
}
