public AuthService(
IUserRepository userRepository,
AuthConfiguration authConfiguration)
{
this.userRepository = userRepository;
this.authConfiguration = authConfiguration;
}
public object Post(
[FromBody] User user,
[FromServices] UserRepository userRepository,
[FromServices] AuthConfiguration authConfiguration,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool validCredentials = false;
if (user != null && !String.IsNullOrWhiteSpace(user.Login))
{
var userTemp = userRepository.GetUser(user.Login);
validCredentials = (userTemp != null &&
user.Login == userTemp.Login &&
user.AccessKey == userTemp.AccessKey);
}
if (validCredentials)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(user.Login, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Login)
}
);
DateTime createDate = DateTime.Now;
DateTime expireDate = createDate +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = authConfiguration.SigningCredentials,
Subject = identity,
NotBefore = createDate,
Expires = expireDate
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = createDate.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = expireDate.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
});
}
else
{
return(new
{
authenticated = false,
message = "Falha ao autenticar"
});
}
}
public AuthController(IAuthProvider authProvider, IMapper mapper,
IOptions <AuthConfiguration> authConfiguration)
{
_mapper = mapper;
_authProvider = authProvider;
_authConfiguration = authConfiguration.Value;
}
public async Task <string> Authenticate(User user, string roleName)
{
var result = await Task.Run(() =>
{
var claims = new List <Claim>()
{
new Claim(ClaimsIdentity.DefaultNameClaimType, user.UserName),
new Claim(ClaimsIdentity.DefaultRoleClaimType, roleName)
};
var identity = new ClaimsIdentity(claims, "jwt", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
var now = DateTime.Now;
var expire = now.AddDays(int.Parse(configuration.GetLifeTime()));
var jwt = new JwtSecurityToken(
issuer: configuration.GetIssuer(),
audience: configuration.GetAudience(),
claims: identity.Claims,
notBefore: now,
expires: expire,
signingCredentials: new SigningCredentials(AuthConfiguration.GetSecurityKey(configuration.GetSecurityKey()), SecurityAlgorithms.HmacSha256)
);
var token = new JwtSecurityTokenHandler().WriteToken(jwt);
return(token);
});
return(result);
}
public static IServiceCollection AddIdentity<TCurrentUserService>(this IServiceCollection services,
Action<DbContextOptionsBuilder> optionsAction,
Action<AuthConfiguration> authConfigurationAction)
where TCurrentUserService : class, ICurrentUserService
{
services
.AddDbContext<ApplicationIdentityDbContext>(optionsAction);
var configuration = new AuthConfiguration();
authConfigurationAction.Invoke(configuration);
services
.AddSingleton(configuration)
.AddSingleton<JwtTokenService>();
services
.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationIdentityDbContext>();
services
.AddScoped<IUserService, IdentityUserService>()
.AddScoped<ICurrentUserService, TCurrentUserService>();
return services;
}
public static IServiceCollection AddAuth(this IServiceCollection services, AuthConfiguration authConfiguration)
{
//Authorizations
services
.AddIdentity <IdentityUser, IdentityRole>()
.AddEntityFrameworkStores <AppContext>()
.AddDefaultTokenProviders();
//Authentications
var key = Encoding.ASCII.GetBytes(authConfiguration.Secret);
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = false;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
return(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
IConfigurationSection sectionCassandra = Configuration.GetSection(AppSettingsConstants.CASSANDRA_CONNECTION);
services.Configure <CassandraConnectionSetting>(sectionCassandra);
IConfigurationSection sectionAuth = Configuration.GetSection(AppSettingsConstants.AUTH_CONFIGURATION);
AuthConfiguration authConfiguration = sectionAuth.Get <AuthConfiguration>();
services.AddCassandra();
services.AddApplicationQuery();
services.AddApplicationCommand();
#if DEBUG
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddSwagger(_version, authConfiguration);
#else
services.AddMvcCore().AddJsonFormatters();
#endif
services.AddAuthentication()
.AddIdentityServerAuthentication(options =>
{
options.Authority = authConfiguration.Host;
options.RequireHttpsMetadata = false;
options.ApiName = authConfiguration.ApiName;
});
}
private void ConfigureAuth(IServiceCollection services)
{
string domain = Configuration["Authentication:Domain"];
domain = $"https://{domain}/";
//Authentication service
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
options.Authority = domain;
options.Audience = Configuration["Authentication:Audience"];
});
//Configure scopes as policies
services.AddAuthorization(options =>
{
var authorizationConfiguration = new AuthConfiguration();
Configuration.GetSection("Authorization").Bind(authorizationConfiguration);
if (authorizationConfiguration.Scopes != null)
{
foreach (string scope in authorizationConfiguration.Scopes)
{
options.AddPolicy(scope, policy => policy.Requirements.Add(new ScopeRequirement(scope, domain)));
}
}
});
//Register the scope authorization handler
services.AddSingleton <IAuthorizationHandler, ScopeHandler>();
}
private static AuthenticationBuilder AddTokenAuthentication(this IServiceCollection services, IConfiguration configuration)
{
AuthConfiguration authConfiguration = new AuthConfiguration(configuration);
return(services
.AddSingleton(authConfiguration)
.AddAuthentication(options => {
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, jwtBearerOptions => {
jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = authConfiguration.Key,
ValidateIssuer = true,
ValidIssuer = authConfiguration.Issuer,
ValidateAudience = true,
ValidAudience = authConfiguration.Audience,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
}));
}
public void ConfigureServices(IServiceCollection services)
{
var authSection = Configuration.GetSection("Auth").CheckExistence();
var authConfig = new AuthConfiguration();
authSection.Bind(authConfig);
services.AddAuthentication(opts =>
{
opts.DefaultAuthenticateScheme = "Cookie";
opts.DefaultSignInScheme = "Cookie";
opts.DefaultChallengeScheme = "AuthServer";
})
.AddCookie("Cookie", opts =>
{
})
.AddOAuth("AuthServer", opts =>
{
opts.ClientId = authConfig.ClientId;
opts.ClientSecret = authConfig.ClientSecret;
opts.CallbackPath = authConfig.CallbackPath;
opts.AuthorizationEndpoint = authConfig.AuthorizationEndpoint;
opts.TokenEndpoint = authConfig.TokenEndpoint;
});
services.AddControllersWithViews();
}
public static async Task <int> Invoke(CancellationToken token, string[] urls, string[] metricUrls, bool metrics, string diagnosticPort, bool noAuth, bool tempApiKey, bool noHttpEgress)
{
try
{
AuthConfiguration authenticationOptions = HostBuilderHelper.CreateAuthConfiguration(noAuth, tempApiKey);
IHost host = HostBuilderHelper.CreateHostBuilder(urls, metricUrls, metrics, diagnosticPort, authenticationOptions)
.ConfigureServices(authenticationOptions, noHttpEgress)
.Build();
try
{
await host.StartAsync(token);
await host.WaitForShutdownAsync(token);
}
catch (MonitoringException)
{
// It is the responsibility of throwers to ensure that the exceptions are logged.
return(-1);
}
catch (OptionsValidationException ex)
{
host.Services.GetRequiredService <ILoggerFactory>()
.CreateLogger(typeof(CollectCommandHandler))
.OptionsValidationFailure(ex);
return(-1);
}
catch (OperationCanceledException) when(token.IsCancellationRequested)
{
// The host will throw a OperationCanceledException if it cannot shut down the
// hosted services gracefully within the shut down timeout period. Handle the
// exception and let the tool exit gracefully.
return(0);
}
finally
{
if (host is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync();
}
else
{
host.Dispose();
}
}
}
catch (FormatException ex)
{
Console.Error.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Console.Error.WriteLine(ex.InnerException.Message);
}
return(-1);
}
return(0);
}
public override void Load(IServiceCollection services)
{
var config = new ConfigurationBuilder()
.AddJsonFile(_configName, optional: true, reloadOnChange: false)
.AddEnvironmentVariables()
.AddAzureAppConfiguration(options =>
{
options.Connect(Environment.GetEnvironmentVariable(EnvironmentVariableNames.ENV_CONFIG_CONNECTION))
.Select(KeyFilter.Any, LabelFilter.Null)
.Select(KeyFilter.Any, Environment.GetEnvironmentVariable(EnvironmentVariableNames.SYSTEM_ENVIRONMENT));
})
.Build();
var _config = new AuthConfiguration()
{
ApiKey = config[EnvironmentVariableNames.ENV_HF_API_KEY],
AuthURL = config[EnvironmentVariableNames.ENV_AUTH_URL],
Issuers = config.GetSection("ISSUERS")?.Get <string[]>(),
Audiences = config.GetSection("AUDIENCES")?.Get <string[]>(),
Audience = config[AppConfigurationKey.AUDIENCE],
ClientId = config[AppConfigurationKey.CLIENT_ID],
ClientSecret = config[AppConfigurationKey.CLIENT_SECRET],
Issuer = config[AppConfigurationKey.ISSUER],
AccessToken = config[AppConfigurationKey.ACCESS_TOKEN],
};
var _authHelper = new AuthenticationHelper(_authServiceName, config[EnvironmentVariableNames.ENV_AUTH_URL], _config);
var _raygun = new RaygunClient(config[EnvironmentVariableNames.ENV_RAYGUN_API_KEY]);
services.AddSingleton <IAuthenticationHelper>(_authHelper);
services.AddSingleton <IConfiguration>(config);
services.AddSingleton(_raygun);
services.AddSingleton <HttpClient>();
}
public UserService(IGenericRepository <Guid> genericRepository, IUnitOfWork unitOfWork,
IMapper mapper, IConfiguration configuration)
{
this.genericRepository = genericRepository;
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.AuthConfiguration = configuration.GetSection(AuthConfiguration.Section).Get <AuthConfiguration>();
}
public AccountService(UserManager <User> userManager,
AuthConfiguration authConfiguration,
ApplicationDbContext db)
{
_userManager = userManager;
_authConfiguration = authConfiguration;
this.db = db;
}
protected override void ConfigureRequestContainer(IKernel container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
RavenDbConfiguration.ConfigureSession(container);
AuthConfiguration.ConfigureRequest(container);
ServiceConfiguration.ConfigureRequestServices(container);
}
public LogoutController(
LogoutSessionManager logoutSessions,
IOptions <AuthConfiguration> optionsAuthConfiguration,
IHttpClientFactory httpClientFactory)
{
_optionsAuthConfiguration = optionsAuthConfiguration.Value;
LogoutSessions = logoutSessions;
_httpClient = httpClientFactory.CreateClient();
}
public HomeController(
IOptions <AuthConfiguration> optionsAuthConfiguration,
IConfiguration configuration,
IHttpClientFactory clientFactory)
{
_configuration = configuration;
_optionsAuthConfiguration = optionsAuthConfiguration.Value;
_clientFactory = clientFactory;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
SwaggerConfiguration.AddSwaggerSetup(services);
EntityFrameworkConfiguration.AddEntityFrameworkSetup(services, Configuration);
DependencyInjectionConfiguration.AddDependencyInjectionSetup(services);
AutoMapperConfiguration.AddAutoMapperSetup(services);
AuthConfiguration.AddAuthenticationSetup(services, Configuration);
}
public AuthServiceTests()
{
this.authConfiguration = new AuthConfiguration
{
Audience = "http://localhost:12345",
Issuer = "http://localhost:12345",
Key = "checkoutpaymentgateway2020testkey"
};
this.target = new AuthService(authConfiguration);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connString = Configuration.GetConnectionString("DefaultConnection");
services.AddDbContext <StepCoreContext>(option => option.UseSqlServer(connString));
IocConfiguration.Init(Configuration, services);
AuthConfiguration.Init(Configuration, services);
services.AddControllers();
services.AddCors(opt =>
{
opt.AddPolicy("AllowMyOrigin", builder => builder.AllowAnyHeader().AllowAnyOrigin().AllowAnyMethod());
});
}
public SamlController(ILoggerFactory logger, IOptions <AuthConfiguration> spidConfiguration,
RequestOptionFactory requestOptionFactory, IAuthRequest authRequest, IAuthResponse authResponse, ILogoutResponse logoutResponse,
ITokenService tokenService, IdpHelper idpHelper, IDataProtectionService dataProtectionService)
{
_logger = logger.CreateLogger(LogCategories.AUTHENGINE);
_traceLogger = logger.CreateLogger(LogCategories.SAMLTRACE);
_sessionAuthLogger = logger.CreateLogger(LogCategories.AUTHSESSION);
_spidConfiguration = spidConfiguration?.Value;
_requestOptionFactory = requestOptionFactory;
_authRequest = authRequest;
_authResponse = authResponse;
_logoutResponse = logoutResponse;
_tokenService = tokenService;
_idpHelper = idpHelper;
_dataProtectionService = dataProtectionService;
}
public void ConfigureServices(IServiceCollection services)
{
AuthConfiguration.ConfigureServices(services, _appSettings);
GraphQlConfiguration.ConfigureServices(services, _environment);
ConfigureDatabaseServices(services);
ConfigureMessageSenderServices(services);
ConfigureRequestResponseServices(services);
ConfigureSessionServices(services);
services.AddHttpClient();
services
.AddHealthChecks()
.AddDbContextCheck <Data.ApplicationDbContext>();
services.AddSingleton(_appSettings);
services.AddSingleton(_environment);
// services.AddDatabaseDeveloperPageExceptionFilter();
}
public static IServiceCollection AddCommonAuthentication(this IServiceCollection services,
AuthConfiguration authConfiguration)
{
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
services.AddAuthentication(config =>
{
config.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(config =>
{
config.Authority = authConfiguration.Authority;
config.Audience = authConfiguration.Audience;
config.RequireHttpsMetadata = false;
});
return(services);
}
public static IServiceCollection ConfigureApllicationServices(this IServiceCollection services, IConfiguration configuration)
{
var authConfiguration = new AuthConfiguration
{
ExpireTimeMinutes_Client = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Client"),
ExpireTimeMinutes_Password = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Password"),
ExpireTimeMinutes_Refresh = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Refresh"),
Router = configuration.GetValue <string>("AuthConfiguration:Router"),
TokenKey = configuration.GetValue <string>("AuthConfiguration:TokenKey"),
RefreshToken_TimeValidHour = configuration.GetValue <int>("AuthConfiguration:RefreshToken_TimeValidHour"),
};
services
.AddSingleton <IHttpContextAccessor, HttpContextAccessor>()
.AddRabbitMQ(configuration, options => {
options.AddConnection("rabbitmq");
})
.AddScoped(serviceProvider => {
var token = serviceProvider.GetRequiredService <TokenRead>();
var value = new SessionUser();
if (token != null && token.Claims != null)
{
var user_Id = token.GetValue("Id_User");
var account_Id = token.GetValue("Account_Id");
if (int.TryParse(user_Id, out int userId) && int.TryParse(account_Id, out int accountId))
{
value.Id = userId;
value.AccountId = accountId;
}
}
return(value);
})
.Register(configuration)
.AddCorsServices(configuration)
.AddResponseCompression()
.AddSimpleOAuth(option =>
{
option.AddKeyToken(authConfiguration.TokenKey);
option.AddAuthRouter(authConfiguration.Router);
})
.AddSingleton(_ => authConfiguration);
return(services);
}
public void ConfigureServices(IServiceCollection services)
{
// DIConfiguration.Config(services, Configuration);
DbConfiguration.Config(services, Configuration);
AuthConfiguration.Config(services);
services.AddAntiforgery(opt =>
{
opt.HeaderName = "X-XSRF-TOKEN";
opt.Cookie.Name = "XSRF-TOKEN";
opt.Cookie.HttpOnly = true;
opt.Cookie.Path = "/";
});
services.AddMemoryCache();
services.AddDistributedMemoryCache();
services.AddSession(opt => { opt.IdleTimeout = TimeSpan.FromDays(1); });
services.AddLocalization(options => options.ResourcesPath = "Resources");
services.AddRouting(options => options.LowercaseUrls = true);
services.AddMvc(
options =>
{
options.ModelMetadataDetailsProviders.Add(
new CustomValidationMetadataProvider("Portal.SiteResources", typeof(SiteResources)));
}
)
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
})
.AddDataAnnotationsLocalization()
.AddViewLocalization();
services.AddAutoMapper();
// services.Configure<ApiBehaviorOptions>(options =>
// {
// options.SuppressModelStateInvalidFilter = true;
// options.SuppressConsumesConstraintForFormFileParameters = true;
// });
}
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.AddScoped <IConnectionBloodOrange, UnitOfWorkBloodOrange>(x =>
new UnitOfWorkBloodOrange(Configuration.GetSection("Configuracoes").GetSection("Connection-BloodOrange").Value));
services.AddScoped <IMessaging, Messages>(x => new Messages(Configuration.GetSection("Messages").Value));
services.Configure <ApplicationConfiguration>(Configuration.GetSection("Aplicacao"));
services.AddTransient <PerformaceFilters>();
services.AddTransient <SecurityFilter>();
AuthConfiguration.Register(services, Configuration);
AutoMapperConfiguration.Register(services, Configuration);
DependencyInjectionConfiguration.Register(services, Configuration);
services.AddMvc(options =>
{
options.Filters.AddService <PerformaceFilters>();
options.Filters.AddService <SecurityFilter>();
options.Filters.Add(typeof(ErrorFilters));
}).AddJsonOptions(options =>
{
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
}).SetCompatibilityVersion(CompatibilityVersion.Latest);
SwaggerApiVersioningConfiguration.Register(services);
var corsBuilder = new CorsPolicyBuilder()
.AllowAnyHeader()
.AllowAnyMethod()
.AllowAnyOrigin();
services.AddCors(options =>
{
options.AddPolicy("SiteCorsPolicy", corsBuilder.Build());
});
}
public ScheduleTask(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
_authConfiguration = config
.GetSection(nameof(AuthConfiguration))
.Get <AuthConfiguration>();
_myChannelConfiguration = config
.GetSection(nameof(MyChannelConfiguration))
.Get <MyChannelConfiguration>();
_reportConfiguration = config
.GetSection(nameof(ReportConfiguration))
.Get <ReportConfiguration>();
}
public void Configuration(IAppBuilder app)
{
var httpConfig = new HttpConfiguration();
AuthConfiguration.ConfigureOAuthTokenGeneration(app);
AuthConfiguration.ConfigureOAuthTokenConsumption(app);
OdataConfiguration.Register(httpConfig);
app.UseCors(CorsOptions.AllowAll);
JsConfig.EmitCamelCaseNames = true;
WebApiConfigurations.ConfigureWebApi(httpConfig);
httpConfig.EnsureInitialized();
}
public TelegramCore(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
_authConfiguration = config
.GetSection(nameof(AuthConfiguration))
.Get <AuthConfiguration>();
_keywordsConfiguration = config
.GetSection(nameof(KeywordsConfiguration))
.Get <KeywordsConfiguration>();
_myChannelConfiguration = config
.GetSection(nameof(MyChannelConfiguration))
.Get <MyChannelConfiguration>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
AppSettings.Configure(services, Configuration, Environment.IsDevelopment() ? @"c:\" : Environment.ContentRootPath);
//dependency injection goes here.
services.AddHttpContextAccessor();
services.AddTransient <HealthCheckDelegatingHandler>();
// TODO: remove httpClientBuilder
// This bypasses any certificate validation on proxy requests
// Only done due to local APIs not having certificates configured
services.AddProxy(httpClientBuilder => httpClientBuilder.ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
{
ClientCertificateOptions = ClientCertificateOption.Manual,
ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) => true
}));
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddControllers();
// Add authentication services
var authConfiguration = new AuthConfiguration(Configuration, "WebAppConfiguration");
services.AddAuthentication(authConfiguration, allowNonSecureCookie: Environment.IsDevelopment());
services.AddAuthorisation(authConfiguration);
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
services.AddHealthChecks();
services.AddHealthChecksUI(setupSettings: setup =>
{
setup.UseApiEndpointDelegatingHandler <HealthCheckDelegatingHandler>();
})
.AddInMemoryStorage();
}
