public static void ConfigureComponentServices(this IServiceCollection services, IConfiguration configuration, IHostEnvironment environment, ILogger logger, params Assembly[] assemblies)
{
var configServices = new ConfigurationServices
{
Services = services,
Configuration = configuration,
Environment = environment,
Logger = logger
};
logger.LogInformation("scanning {0} assemblies for service configuration", assemblies.Length);
foreach (var assembly in assemblies)
{
var configurations = assembly.CreateInstancesOf <IConfigureComponentServices>();
logger.LogDebug("assembly {0}: discovered {1} component configurations", assembly.GetName().Name, configurations.Length);
foreach (var config in configurations)
{
logger.LogDebug("configuring {1} services", config.GetType().FullName);
config.ConfigureServices(configServices);
}
}
logger.LogInformation("finished service configuration scan");
}
private void sendMessageCodeActivity_SendMessage_ExecuteCode(object sender, EventArgs e)
{
CloseCurrentView();
var timeZoneStandardName = GetBinding <string>("TimeZonesSelected");
var timezoneId = TimeZoneInfo.FindSystemTimeZoneById(timeZoneStandardName);
var timezoneTransform = XDocument.Parse(String.Format(TimezoneXslt, timezoneId.Id));
ConfigurationServices.TransformConfiguration(timezoneTransform, false);
HostingEnvironment.InitiateShutdown();
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
managementConsoleMessageService.ShowGlobalMessage(DialogType.Message,
StringResourceSystemFacade.GetString("Composite.Management", "SendMessageToConsolesWorkflow.SuccessMessage.TimezoneChangedTitle"),
StringResourceSystemFacade.GetString("Composite.Management", "SendMessageToConsolesWorkflow.SuccessMessage.TimezoneChangedMessage"));
managementConsoleMessageService.RebootConsole();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigurationServices.ConfigureServices(services,
Configuration.GetConnectionString("DefaultConnection"));
services.AddControllers();
services.AddRazorPages();
services.AddAuthorization();
services.AddCors();
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new AutoMapperProfiles());
});
IMapper mapper = mappingConfig.CreateMapper();
services.AddSingleton(mapper);
services.AddScoped <Seed>();
services.AddScoped <IUserService, UserService>();
services.AddTransient <IAuthService, AuthService>();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(Configuration.GetSection("AuthKey:Token").Value)),
ValidateIssuer = false,
ValidateAudience = false
};
});
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <IMetadataRepository, MetadataRepository>();
}
public ConfigurationModule(ServerServices serverServices, ChannelServices channelServices, ConfigurationServices configurationServices)
{
_serverServices = serverServices;
_configurationServices = configurationServices;
_channelServices = channelServices;
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
var services = configurationServices.Services;
var configuration = configurationServices.Configuration;
services.Configure <JsonOptions>(opts =>
{
opts.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
opts.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
});
services.AddAuthentication()
//JWT tokens handling
.AddJwtBearer("jwt", options =>
{
options.BackchannelHttpHandler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
};
configuration.GetSection("auth:jwt").Bind(options);
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = false
};
// if token does not contain a dot, it is a reference token, forward to introspection auth scheme
options.ForwardDefaultSelector = ctx =>
{
var authHeader = (string)ctx.Request.Headers["Authorization"];
if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
{
return(null);
}
return(authHeader.Substring("Bearer ".Length).Trim().Contains('.') ? null : "introspection");
};
options.Events = new JwtBearerEvents
{
OnTokenValidated = async ctx =>
{
await Task.CompletedTask;
var logger = ctx.HttpContext.RequestServices.GetRequiredService <ILogger <JwtBearerEvents> >();
var userInfo = ctx.Principal.FindFirstValue("userInfo");
logger.LogDebug("{0}", userInfo);
},
OnAuthenticationFailed = async ctx =>
{
await Task.CompletedTask;
var logger = ctx.HttpContext.RequestServices.GetRequiredService <ILogger <JwtBearerEvents> >();
logger.LogError(ctx.Exception, "JWT authantication failed");
}
};
})
//reference tokens handling
.AddOAuth2Introspection("introspection", options =>
{
options.EnableCaching = true;
options.CacheDuration = TimeSpan.FromMinutes(20);
configuration.GetSection("auth:introspection").Bind(options);
options.Events = new OAuth2IntrospectionEvents
{
OnTokenValidated = async ctx =>
{
await Task.CompletedTask;
var logger = ctx.HttpContext.RequestServices.GetRequiredService <ILogger <OAuth2IntrospectionEvents> >();
var userInfo = ctx.Principal?.FindFirst("userInfo");
logger.LogDebug("{0}", userInfo);
},
OnAuthenticationFailed = async ctx =>
{
await Task.CompletedTask;
var logger = ctx.HttpContext.RequestServices.GetRequiredService <ILogger <JwtBearerEvents> >();
logger.LogError(ctx?.Result?.Failure, "Introspection authantication failed");
}
};
});
services.AddAuthorization(options =>
{
options.AddPolicy(JwtBearerDefaults.AuthenticationScheme, policy =>
{
policy
.RequireAuthenticatedUser()
.AddAuthenticationSchemes("jwt")
.RequireClaim("scope", "registrants-portal-api");
});
options.DefaultPolicy = options.GetPolicy(JwtBearerDefaults.AuthenticationScheme) ?? null !;
});
services.Configure <OpenApiDocumentMiddlewareSettings>(options =>
{
options.Path = "/api/openapi/{documentName}/openapi.json";
options.DocumentName = "Registrants Portal API";
options.PostProcess = (document, req) =>
{
document.Info.Title = "Registrants Portal API";
};
});
services.Configure <SwaggerUi3Settings>(options =>
{
options.Path = "/api/openapi";
options.DocumentTitle = "Registrants Portal API Documentation";
options.DocumentPath = "/api/openapi/{documentName}/openapi.json";
});
services.AddOpenApiDocument(document =>
{
document.AddSecurity("bearer token", Array.Empty <string>(), new OpenApiSecurityScheme
{
Type = OpenApiSecuritySchemeType.Http,
Scheme = "Bearer",
BearerFormat = "paste token here",
In = OpenApiSecurityApiKeyLocation.Header
});
document.OperationProcessors.Add(new AspNetCoreOperationSecurityScopeProcessor("bearer token"));
document.GenerateAbstractProperties = true;
});
services.AddTransient <IEvacuationSearchService, EvacuationSearchService>();
services.AddTransient <IProfileInviteService, ProfileInviteService>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <IPrintRequestsRepository, PrintRequestsRepository>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <ICaseRepository, CaseRepository>();
configurationServices.Services.AddTransient <IEvacuationRepository, EvacuationRepository>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddSingleton(sp => new CacheSyncManager(sp.GetRequiredService <ILogger <CacheSyncManager> >()));
configurationServices.Services.AddSingleton <ICache, Cache>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <ISearchEngine, SearchEngine>();
}
private void Apply()
{
LicenseInformation = DetermineLicenseInformation();
ConfigurationServices.NotifyConfigurationChangedEvent();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
var options = configurationServices.Configuration.GetSection("messaging").Get <MessagingOptions>() ?? new MessagingOptions()
{
Mode = MessagingMode.Server
};
configurationServices.Services.AddGrpc(opts =>
{
opts.EnableDetailedErrors = configurationServices.Environment.IsDevelopment();
});
if (options.Mode == MessagingMode.Server || options.Mode == MessagingMode.Both)
{
configurationServices.Services.Configure <MessageHandlerRegistryOptions>(opts => { });
configurationServices.Services.AddSingleton <MessageHandlerRegistry>();
configurationServices.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddScheme <AuthenticationSchemeOptions, AnonymousAuthenticationHandler>(AnonymousAuthenticationHandler.AuthenticationScheme, opts => { })
.AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, opts =>
{
configurationServices.Configuration.GetSection("messaging:oauth").Bind(opts);
opts.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = false,
ValidateIssuer = true,
RequireSignedTokens = true,
RequireAudience = false,
RequireExpirationTime = true,
ValidateLifetime = true,
ClockSkew = TimeSpan.FromSeconds(60),
NameClaimType = ClaimTypes.Upn,
RoleClaimType = ClaimTypes.Role,
ValidateActor = true,
ValidateIssuerSigningKey = false,
};
opts.Events = new JwtBearerEvents
{
OnAuthenticationFailed = async c =>
{
await Task.CompletedTask;
var logger = c.HttpContext.RequestServices.GetRequiredService <ILoggerFactory>().CreateLogger("JwtBearer");
logger.LogError(c.Exception, $"Error authenticating token");
},
OnTokenValidated = async c =>
{
await Task.CompletedTask;
var logger = c.HttpContext.RequestServices.GetRequiredService <ILoggerFactory>().CreateLogger("JwtBearer");
if (c.Request.Headers.TryGetValue("_user", out var userToken))
{
var jwtHandler = new JwtSecurityTokenHandler();
userToken = userToken[0].Replace("bearer ", string.Empty, true, null);
if (!jwtHandler.CanReadToken(userToken))
{
throw new InvalidOperationException($"can't read user token");
}
//TODO: validate token and add as identity to the principal
}
logger.LogDebug("Token validated for {0}", c.Principal?.Identity?.Name);
}
};
opts.Validate();
});
private void SettingsPage_Loaded(object sender, RoutedEventArgs e)
{
_tutorialModels = ConfigurationServices.GetTutorialLinks();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.TryAddSingleton <ResolverFactory>(new DnsResolverFactory(refreshInterval: TimeSpan.FromSeconds(15)));
configurationServices.Services.TryAddSingleton <LoadBalancerFactory, RoundRobinBalancerFactory>();
configurationServices.Services.AddGrpc(opts =>
{
opts.EnableDetailedErrors = configurationServices.Environment.IsDevelopment();
});
var pdfGeneratorUrl = configurationServices.Configuration.GetValue <Uri>("pdfGenerator:url");
var allowUntrustedCertificates = configurationServices.Configuration.GetValue("pdfGenerator:allowInvalidServerCertificate", false);
if (pdfGeneratorUrl == null)
{
configurationServices.Logger.LogWarning("PdfGenerator:url env var is not set, PdfGenerator will not be available");
return;
}
var httpClientBuilder = configurationServices.Services.AddGrpcClient <Generator.GeneratorClient>(opts =>
{
opts.Address = pdfGeneratorUrl;
}).ConfigurePrimaryHttpMessageHandler(() =>
{
var handler = new SocketsHttpHandler()
{
EnableMultipleHttp2Connections = true,
PooledConnectionIdleTimeout = TimeSpan.FromMinutes(2),
PooledConnectionLifetime = TimeSpan.FromSeconds(20),
KeepAlivePingDelay = TimeSpan.FromSeconds(20),
KeepAlivePingTimeout = TimeSpan.FromSeconds(20),
KeepAlivePingPolicy = HttpKeepAlivePingPolicy.WithActiveRequests
};
if (allowUntrustedCertificates)
{
handler.SslOptions = new SslClientAuthenticationOptions {
RemoteCertificateValidationCallback = DangerousCertificationValidation
};
}
return(handler);
}).ConfigureChannel(opts =>
{
if (pdfGeneratorUrl.Scheme == "dns")
{
opts.Credentials = ChannelCredentials.SecureSsl;
}
opts.ServiceConfig = new ServiceConfig
{
LoadBalancingConfigs = { new RoundRobinConfig() },
MethodConfigs =
{
new MethodConfig
{
RetryPolicy = new RetryPolicy
{
MaxAttempts = 5,
InitialBackoff = TimeSpan.FromSeconds(1),
MaxBackoff = TimeSpan.FromSeconds(5),
BackoffMultiplier = 1.5,
RetryableStatusCodes ={ StatusCode.Unavailable }
}
}
}
};
}).EnableCallContextPropagation(opts => opts.SuppressContextNotFoundErrors = true);
configurationServices.Services.TryAddTransient <IPdfGenerator, PdfGenerator>();
}
private static TInterface GetOrCreate <TInterface>(ref TInterface storage, Type implementationType) where TInterface : class
{
return(GetOrCreate(ref storage, () => ConfigurationServices.CreateInstance <TInterface>(implementationType)));
}
private void UpdateSettingsExecuted()
{
ConfigurationServices.SaveConfig(ConfigurationSettings);
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <IPaymentRepository, PaymentRepository>();
configurationServices.Services.AddTransient <ICasGateway, CasGateway>();
configurationServices.Services.AddTransient <ICasSystemConfigurationProvider, CasSystemConfigurationProvider>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <ITransformator, HbsTransformator>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
var services = configurationServices.Services;
var configuration = configurationServices.Configuration;
var options = configuration.GetSection("Dynamics").Get <DynamicsOptions>();
services.Configure <DynamicsOptions>(opts => configuration.GetSection("Dynamics").Bind(opts));
var adfsTokenErrorHandlingPolicy = HttpPolicyExtensions.HandleTransientHttpError()
.CircuitBreakerAsync(
options.CircuitBreakerNumberOfErrors,
TimeSpan.FromSeconds(options.CircuitBreakerResetInSeconds),
OnBreak,
OnReset);
services
.AddHttpClient("adfs_token")
.SetHandlerLifetime(TimeSpan.FromMinutes(30))
.AddPolicyHandler((sp, request) =>
{
var ctx = request.GetPolicyExecutionContext() ?? new Context();
ctx["_serviceprovider"] = sp;
ctx["_source"] = "adfs-circuitbreaker";
request.SetPolicyExecutionContext(ctx);
return(adfsTokenErrorHandlingPolicy);
})
;
services.AddSingleton <ISecurityTokenProvider, ADFSSecurityTokenProvider>();
var dynamicsErrorHandlingPolicy = HttpPolicyExtensions.HandleTransientHttpError()
.Or <TaskCanceledException>() // when Dynamics API is rejecting requests
.Or <DataServiceRequestException>()
.Or <DataServiceTransportException>()
.CircuitBreakerAsync(
options.CircuitBreakerNumberOfErrors,
TimeSpan.FromSeconds(options.CircuitBreakerResetInSeconds),
OnBreak,
OnReset);
services
.AddODataClient("dynamics")
.AddODataClientHandler <DynamicsODataClientHandler>()
.AddHttpClient()
.ConfigureHttpClient(c => c.Timeout = options.HttpClientTimeout)
.SetHandlerLifetime(TimeSpan.FromMinutes(30))
.AddPolicyHandler((sp, request) =>
{
var ctx = request.GetPolicyExecutionContext() ?? new Context();
ctx["_serviceprovider"] = sp;
ctx["_source"] = "dynamics-circuitbreaker";
request.SetPolicyExecutionContext(ctx);
return(dynamicsErrorHandlingPolicy);
})
;
services.AddSingleton <IEssContextFactory, EssContextFactory>();
services.AddTransient(sp => sp.GetRequiredService <IEssContextFactory>().Create());
services.AddTransient <IEssContextStateReporter, EssContextStateReporter>();
services.AddTransient <IVersionInformationProvider, DynamicSchemasVersionInformationProvider>();
}
internal static void ValidateXslt(List <PackageFragmentValidationResult> validationResults, Func <XElement> elementProvider, string elementName, Func <XAttribute> xsltPathAttributeProvider, Func <string> xsltFilePathProvider, IZipFileSystem zipFileSystem, bool validateResultingConfigurationFile)
{
if (elementProvider() == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingElement")
.FormatWith(elementName));
return;
}
string xslFilePath = xsltFilePathProvider();
if (xslFilePath == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingAttribute")
.FormatWith(_xsltFilePathAttributeName), elementProvider());
return;
}
if (zipFileSystem.ContainsFile(xslFilePath) == false)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.PathDoesNotExist")
.FormatWith(xslFilePath), xsltPathAttributeProvider());
return;
}
if (!PathUtil.WritePermissionGranted(ConfigurationServices.FileConfigurationSourcePath))
{
validationResults.AddFatal(
GetResourceString("NotEnoughNtfsPermissions")
.FormatWith(ConfigurationServices.FileConfigurationSourcePath));
return;
}
using (Stream xsltFileStream = zipFileSystem.GetFileStream(xslFilePath))
{
using (TextReader xsltTextReader = new C1StreamReader(xsltFileStream))
{
XDocument xslt = null;
try
{
xslt = XDocument.Load(xsltTextReader);
}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.UnableToParsXslt")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
if (xslt != null && validateResultingConfigurationFile)
{
try
{
ConfigurationServices.TransformConfiguration(xslt, true);
}
//catch (ConfigurationException ex)
//{
// validationResults.AddFatal(
// GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
// .FormatWith(xsltFilePathProvider(), ex.Message), xsltPathAttributeProvider());
//}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
}
}
}
}
/// <summary>
/// Sets the compiler factory.
/// </summary>
/// <param name="typeName">The factory type.</param>
private static void SetCompilerServiceFactory(string typeName)
{
var factory = ConfigurationServices.CreateInstance <ICompilerServiceFactory>(typeName);
CompilerServiceFactory = factory;
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
var services = configurationServices.Services;
var configuration = configurationServices.Configuration;
var options = configuration.GetSection("Dynamics").Get <DynamicsOptions>();
services.Configure <DynamicsOptions>(opts => configuration.GetSection("Dynamics").Bind(opts));
services
.AddHttpClient("adfs_token")
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
/*.AddResiliencyPolicies(new IPolicyBuilder<HttpResponseMessage>[]
* {
* new HttpClientCircuitBreakerPolicy
* {
* NumberOfErrors = options.Adfs.CircuitBreakerNumberOfErrors,
* ResetDuration = TimeSpan.FromSeconds(options.Adfs.CircuitBreakerResetInSeconds),
* OnBreak = (sp, t, e) => { OnBreak("adfs_token", sp, t, e); },
* OnReset = sp => { OnReset("adfs_token", sp); }
* },
* new HttpClientBulkheadIsolationPolicy
* {
* MaxParallelization = 10,
* QueueSize = 100
* },
* new HttpClientRetryPolicy
* {
* NumberOfRetries = options.NumberOfRetries,
* WaitDurationBetweenRetries = TimeSpan.FromSeconds(options.RetryWaitTimeInSeconds),
* OnRetry = (sp, t, e) => { OnRetry("adfs_token", sp, t, e); }
* },
* new HttpClientTimeoutPolicy
* {
* Timeout = TimeSpan.FromSeconds(options.Adfs.TimeoutInSeconds),
* OnTimeout = (sp, t, e) => { OnTimeout("adfs_token", sp, t, e); }
* }
* })*/
;
services.AddTransient <ISecurityTokenProvider, CachedADFSSecurityTokenProvider>();
services
.AddODataClient("dynamics")
.AddODataClientHandler <DynamicsODataClientHandler>()
.AddHttpClient()
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.ConfigureHttpClient((sp, c) =>
{
var options = sp.GetRequiredService <IOptions <DynamicsOptions> >().Value;
var tokenProvider = sp.GetRequiredService <ISecurityTokenProvider>();
c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokenProvider.AcquireToken().GetAwaiter().GetResult());
})
/*.AddResiliencyPolicies(new IPolicyBuilder<HttpResponseMessage>[]
* {
* new HttpClientCircuitBreakerPolicy
* {
* NumberOfErrors = options.CircuitBreakerNumberOfErrors,
* ResetDuration = TimeSpan.FromSeconds(options.CircuitBreakerResetInSeconds),
* OnBreak = (sp, t, e) => { OnBreak("dynamics", sp, t, e); },
* OnReset = sp => { OnReset("dynamics", sp); }
* },
* new DynamicsHttpClientRetryPolicy
* {
* NumberOfRetries = options.NumberOfRetries,
* WaitDurationBetweenRetries = TimeSpan.FromSeconds(options.RetryWaitTimeInSeconds),
* OnRetry = (sp, t, e) => { OnRetry("dynamics", sp, t, e); }
* },
* new HttpClientTimeoutPolicy
* {
* Timeout = TimeSpan.FromSeconds(options.TimeoutInSeconds),
* OnTimeout = (sp, t, e) => { OnTimeout("dynamics", sp, t, e); }
* }
* })*/
;
services.AddScoped <IEssContextFactory, EssContextFactory>();
services.AddTransient(sp => sp.GetRequiredService <IEssContextFactory>().Create());
services.AddTransient <IEssContextStateReporter, EssContextStateReporter>();
}
public void NotifyConfigurationChangedEvent()
{
ConfigurationServices.NotifyConfigurationChangedEvent();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <IReportRepository, ReportRepository>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <AdminManager>();
configurationServices.Services.Configure <MessageHandlerRegistryOptions>(opts => opts.Add(typeof(AdminManager)));
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
var services = configurationServices.Services;
var env = configurationServices.Environment;
services.Configure <OpenApiDocumentMiddlewareSettings>(options =>
{
options.Path = "/api/openapi/{documentName}/openapi.json";
options.DocumentName = "Responders Portal API";
options.PostProcess = (document, req) =>
{
document.Info.Title = "Responders Portal API";
};
});
services.Configure <SwaggerUi3Settings>(options =>
{
options.Path = "/api/openapi";
options.DocumentTitle = "responders Portal API Documentation";
options.DocumentPath = "/api/openapi/{documentName}/openapi.json";
});
services.AddOpenApiDocument(document =>
{
document.AddSecurity("bearer token", Array.Empty <string>(), new OpenApiSecurityScheme
{
Type = OpenApiSecuritySchemeType.Http,
Scheme = "Bearer",
BearerFormat = "paste token here",
In = OpenApiSecurityApiKeyLocation.Header
});
document.OperationProcessors.Add(new AspNetCoreOperationSecurityScopeProcessor("bearer token"));
document.GenerateAbstractProperties = true;
});
services.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, options =>
{
configurationServices.Configuration.GetSection("jwt").Bind(options);
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = true,
ValidateIssuer = true,
RequireSignedTokens = true,
RequireAudience = true,
RequireExpirationTime = true,
ValidateLifetime = true,
ClockSkew = TimeSpan.FromSeconds(60),
NameClaimType = ClaimTypes.Upn,
RoleClaimType = ClaimTypes.Role,
ValidateActor = true,
ValidateIssuerSigningKey = true,
};
options.Events = new JwtBearerEvents
{
OnAuthenticationFailed = async c =>
{
await Task.CompletedTask;
var logger = c.HttpContext.RequestServices.GetRequiredService <ILoggerFactory>().CreateLogger("JwtBearer");
logger.LogError(c.Exception, $"Error authenticating token");
},
OnTokenValidated = async c =>
{
var logger = c.HttpContext.RequestServices.GetRequiredService <ILoggerFactory>().CreateLogger("JwtBearer");
var userService = c.HttpContext.RequestServices.GetRequiredService <IUserService>();
c.Principal = await userService.GetPrincipal(c.Principal);
logger.LogDebug("Token validated for {0}", c.Principal?.Identity?.Name);
}
};
options.Validate();
});
services.AddAuthorization(options =>
{
options.AddPolicy(JwtBearerDefaults.AuthenticationScheme, policy =>
{
policy.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
//.RequireClaim("scope", "responders-portal-api")
.RequireClaim("user_role")
.RequireClaim("user_team");
});
options.DefaultPolicy = options.GetPolicy(JwtBearerDefaults.AuthenticationScheme) ?? null !;
});
services.AddTransient <IUserService, UserService>();
services.AddTransient <IEvacuationSearchService, EvacuationSearchService>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <ISupplierRepository, SupplierRepository>();
}
public void ConfigureServices(ConfigurationServices configurationServices)
{
configurationServices.Services.AddTransient <IEvacueesRepository, EvacueesRepository>();
configurationServices.Services.AddTransient <IInvitationRepository, EvacueesRepository>();
}
