protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// see https://docs.microsoft.com/en-us/aspnet/core/test/integration-tests for things you could place here
builder?.ConfigureServices(services =>
{
// Build the service provider.
services.BuildServiceProvider();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder?.ConfigureServices(services =>
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
services.AddSingleton <IConfiguration>(configuration);
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseApplicationInsights();
builder?.ConfigureServices(services =>
{
var serviceProvider = new ServiceCollection()
.BuildServiceProvider();
var sp = services.BuildServiceProvider();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseApplicationInsights();
builder?.ConfigureServices(services =>
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
services.AddSingleton <IConfiguration>(configuration);
services.AddTransient <IAppRegistryService, FakeAppRegistryService>();
var serviceProvider = new ServiceCollection().BuildServiceProvider();
services.BuildServiceProvider();
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder?.ConfigureServices(services =>
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
services.AddSingleton <IConfiguration>(configuration);
});
builder.ConfigureTestServices(services =>
{
services.AddTransient <ICacheReloadService, FakeCacheReloadService>();
services.AddHostedService <FakeCacheReloadBackgroundService>();
services.AddTransient(sp => MockCosmosRepo);
services.AddTransient(sp => MockContentPageService);
services.AddTransient <ISubscriptionRegistrationService, FakeSubscriptionRegistrationService>();
services.AddTransient <IWebhooksService, FakeWebhooksService>();
});
}
public static IWebHostBuilder Configure(this IWebHostBuilder builder, Action <IApplicationBuilder> configure)
{
return(builder.ConfigureServices(services => services.AddSingleton <IStartup>(new DelegateStartup(configure))));
}
public static IWebHostBuilder UseHttpListener(this IWebHostBuilder builder)
{
return(builder.ConfigureServices(services => services.AddSingleton <IServer, HttpListenerServer>()));
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) =>
{
services.AddDbContext <TroydonFitnessIdentityContext>(options =>
options.UseSqlServer(
context.Configuration.GetConnectionString("TroydonFitnessIdentityContextConnection")));
services.AddIdentity <TroydonFitnessWebsiteUser, IdentityRole>(options =>
{
options.SignIn.RequireConfirmedAccount = true;
options.SignIn.RequireConfirmedEmail = true;
})
// .AddRoles<ApplicationRole>()
.AddEntityFrameworkStores <TroydonFitnessIdentityContext>()
.AddClaimsPrincipalFactory <AdditionalUserClaimsPrincipalFactory>() // trial
//.AddEntityFrameworkStores<ProductContext>() TODO: see if we need to connect to product db to interact with it using
.AddDefaultTokenProviders();
// config email verification
services.AddScoped <IUserClaimsPrincipalFactory <TroydonFitnessWebsiteUser>,
AdditionalUserClaimsPrincipalFactory>();
// add authorization
services.AddAuthorization(config =>
{
// this policy will apply to users that try to make an order without filling up their profile page with enough data
config.AddPolicy("OrderSuppsAndEquip", policyBuilder =>
{
policyBuilder.RequireCustomClaim(JwtClaimTypes.GivenName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.FamilyName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.BirthDate);
policyBuilder.RequireCustomClaim("AddressLine2");
policyBuilder.RequireCustomClaim("City");
policyBuilder.RequireCustomClaim("State");
policyBuilder.RequireCustomClaim("Zip");
policyBuilder.RequireCustomClaim(JwtClaimTypes.EmailVerified);
policyBuilder.RequireCustomClaim(JwtClaimTypes.PhoneNumber);
});
// this policy will apply to users that try to make an order without filling up their profile page with enough data
config.AddPolicy("OrderPT", policyBuilder =>
{
policyBuilder.RequireCustomClaim(JwtClaimTypes.GivenName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.FamilyName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.BirthDate);
policyBuilder.RequireCustomClaim("AddressLine2");
policyBuilder.RequireCustomClaim("City");
policyBuilder.RequireCustomClaim("State");
policyBuilder.RequireCustomClaim("Zip");
policyBuilder.RequireCustomClaim(JwtClaimTypes.EmailVerified);
policyBuilder.RequireCustomClaim(JwtClaimTypes.PhoneNumber);
policyBuilder.RequireCustomClaim("Bodyfat");
policyBuilder.RequireCustomClaim(JwtClaimTypes.Gender);
policyBuilder.RequireCustomClaim("Height");
policyBuilder.RequireCustomClaim("Weight");
policyBuilder.RequireCustomClaim("ActivityType");
});
// TODO: Test if this will allow both admin and master admin access to somefeatures
config.AddPolicy("ElevatedRights", policyBuilder =>
{
policyBuilder.RequireClaim(JwtClaimTypes.Role, "Master Admin", JwtClaimTypes.Role, "Admin");
});
// master admin policy allows admins access to full CRUD functionality
config.AddPolicy("RequireMasterAdministratorRole", policyBuilder =>
{
policyBuilder.RequireClaim(JwtClaimTypes.Role, "Master Admin");
});
});
services.AddScoped <IAuthorizationHandler, CustomRequireClaimHandler>();
services.Configure <IdentityOptions>(options =>
{
// Default SignIn settings.
options.SignIn.RequireConfirmedEmail = false;
options.SignIn.RequireConfirmedPhoneNumber = false;
// Password settings.
options.Password.RequireDigit = false;
options.Password.RequireLowercase = true;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequiredLength = 6;
options.Password.RequiredUniqueChars = 1;
// Lockout settings.
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(60);
options.Lockout.MaxFailedAccessAttempts = 5;
options.Lockout.AllowedForNewUsers = true;
// User settings.
options.User.AllowedUserNameCharacters =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
options.User.RequireUniqueEmail = true;
});
services.ConfigureApplicationCookie(options =>
{
// Cookie settings
options.Cookie.HttpOnly = true;
options.ExpireTimeSpan = TimeSpan.FromDays(5);
options.Cookie.Name = "TroydonFitnessCookies";
options.LoginPath = "/Identity/Account/Login";
options.LogoutPath = $"/Identity/Account/Logout";
options.AccessDeniedPath = "/Identity/Account/AccessDenied";
options.ReturnUrlParameter = CookieAuthenticationDefaults.ReturnUrlParameter;
options.SlidingExpiration = true;
});
services.Configure <PasswordHasherOptions>(option =>
{
option.IterationCount = 12000;
});
services.Configure <DataProtectionTokenProviderOptions>(options =>
options.TokenLifespan = TimeSpan.FromHours(3));
});
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) => {
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
});
}
public static IWebHostBuilder UseSerilog(this IWebHostBuilder hostBuilder)
{
return(hostBuilder.ConfigureServices((context, collection) => collection.AddLogging(builder => SetupSerilog(context, collection))));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(SetInMemoryDatabase);
base.ConfigureWebHost(builder);
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices(ConfigureServices);
builder.Configure(Configure);
builder.Configure(Configure);
}
private static void ConfigureCustomTraceContext(IWebHostBuilder hostBuilder) =>
hostBuilder.ConfigureServices(services => services
.AddScoped(CustomTraceContextProvider)
.AddSingleton <Action <HttpResponse, ITraceContext> >(CustomTraceContextResponsePropagator)
.AddSingleton <Action <HttpRequestMessage, ITraceContext> >(CustomTraceContextOutgoingPropagator));
public static IWebHostBuilder UseAlteredLog(this IWebHostBuilder builder, string cloudwatchLogGroup = null, Func <LoggerConfiguration, LoggerConfiguration> configureLog = null) => builder
.ConfigureServices((context, serviceCollection) =>
{
configureLog = configureLog ?? (lc => lc);
serviceCollection.AddAlteredLog(cloudwatchLogGroup, loggerConfiguration => configureLog(loggerConfiguration
.Enrich.WithEnvironmentVariable("env", "ASPNETCORE_ENVIRONMENT")
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.ReadFrom.Configuration(context.Configuration)));
})
.UseSerilog()
.AlteredConfigure(app => app
//.Use(AlteredMiddlewareExtensions.AlteredMiddleware)
.Use(AlteredLogMiddlewareExtensions.AlteredLogMiddleware)
);
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) =>
{
services.AddDbContext <IdentityDbContext>(options =>
{
options.UseSqlServer(context.Configuration.GetConnectionString("IdentityDbContextConnection"));
options.UseOpenIddict();
//options.UseInMemoryDatabase(Guid.NewGuid().ToString())
});
//services.AddDefaultIdentity<AppUser>()
// .AddEntityFrameworkStores<IdentityDbContext>();
services.AddIdentity <AppUser, IdentityRole>()
.AddEntityFrameworkStores <IdentityDbContext>()
.AddDefaultTokenProviders()
.AddDefaultUI();
services.AddAuthentication()
.AddJwtBearer(options => {
var siningKeys = new List <SigningCredentials>();
siningKeys.AddDevelopmentCertificate();
options.TokenValidationParameters.IssuerSigningKey = siningKeys.Select(c => c.Key).First();
options.TokenValidationParameters.RoleClaimType = OpenIddictConstants.Claims.Role;
options.TokenValidationParameters.NameClaimType = OpenIddictConstants.Claims.Name;
options.TokenValidationParameters.ValidAudience = "resource_server";
options.TokenValidationParameters.ValidIssuer = "https://localhost:44370/";
})
.AddFacebook(facebookOptions =>
{
facebookOptions.AppId = context.Configuration["Authentication:Facebook:AppId"];
facebookOptions.AppSecret = context.Configuration["Authentication:Facebook:AppSecret"];
}).AddTwitter(twitterOptions =>
{
twitterOptions.ConsumerKey = context.Configuration["Authentication:Twitter:ConsumerKey"];
twitterOptions.ConsumerSecret = context.Configuration["Authentication:Twitter:ConsumerSecret"];
})
.AddGoogle(googleOptions =>
{
googleOptions.ClientId = context.Configuration["Authentication:Google:ClientId"];
googleOptions.ClientSecret = context.Configuration["Authentication:Google:ClientSecret"];
}).AddMicrosoftAccount(microsoftOptions =>
{
microsoftOptions.ClientId = context.Configuration["Authentication:Microsoft:ApplicationId"];
microsoftOptions.ClientSecret = context.Configuration["Authentication:Microsoft:Password"];
});
services.Configure <IdentityOptions>(options =>
{
options.Password.RequiredLength = 8;
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.AllowedForNewUsers = true;
options.SignIn.RequireConfirmedEmail = true;
options.User.RequireUniqueEmail = true;
});
//services.ConfigureApplicationCookie(options => {
// options.AccessDeniedPath = "/Identity/Account/AccessDenied";
// options.Cookie.HttpOnly = true;
// options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
// options.LoginPath = "/Identity/Account/Login";
// options.LogoutPath = "/Identity/Account/Logout";
//});
services.AddSingleton <IEmailSender, LoggerEmailSender>();
services.AddSingleton <ISmsSender, LoggerSmsSender>();
});
}
/// <summary>
/// Register the startup filter <see cref="InterceptionServiceProviderStartupFilter"/>.
/// </summary>
/// <param name="builder">The web host builder to which the <see cref="InterceptionServiceProviderStartupFilter"/> is registered.</param>
/// <returns>The web host builder with the registration of <see cref="InterceptionServiceProviderStartupFilter"/>.</returns>
/// <exception cref="ArgumentNullException">The argument <paramref name="builder"/> is null.</exception>
public static IWebHostBuilder UseInterception(this IWebHostBuilder builder)
{
Guard.ArgumentNotNull(builder, nameof(builder));
return(builder.ConfigureServices(svcs => svcs.AddTransient <IStartupFilter, InterceptionServiceProviderStartupFilter>()));
}
public static IWebHostBuilder UseCoreLogger(
this IWebHostBuilder hostBuilder,
Action <ILoggingBuilder> config)
=> hostBuilder
.ConfigureServices(services => services.Add(new ServiceDescriptor(typeof(ICoreLogger), typeof(CoreLogger), ServiceLifetime.Transient)))
.ConfigureLogging(config);
protected virtual void ConfigureWebHostBuilder(IWebHostBuilder webHostBuilder)
{
webHostBuilder.ConfigureServices(c => c.AddSingleton(HostSettings));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseEnvironment("Testing");
builder.ConfigureServices(services =>
{
services.AddEntityFrameworkSqlite();
// Create a new service provider.
var provider = services
.AddEntityFrameworkSqlite()
.BuildServiceProvider();
// Add a database context (ApplicationDbContext) using an in-memory
// database for testing.
services.AddDbContext <BloggingContext>(options =>
{
options.UseSqlite("DataSource =:memory:");
options.UseInternalServiceProvider(provider);
});
//services.AddDbContext<AppIdentityDbContext>(options =>
//{
// options.UseInMemoryDatabase("Identity");
// options.UseInternalServiceProvider(provider);
//});
// Build the service provider.
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database
// context (ApplicationDbContext).
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <BloggingContext>();
var loggerFactory = scopedServices.GetRequiredService <ILoggerFactory>();
var logger = scopedServices
.GetRequiredService <ILogger <WebTestFixture> >();
// Ensure the database is created.
db.Database.EnsureCreated();
//try
//{
// // Seed the database with test data.
// CatalogContextSeed.SeedAsync(db, loggerFactory).Wait();
// // seed sample user data
// var userManager = scopedServices.GetRequiredService<UserManager<ApplicationUser>>();
// var roleManager = scopedServices.GetRequiredService<RoleManager<IdentityRole>>();
// AppIdentityDbContextSeed.SeedAsync(userManager, roleManager).Wait();
//}
//catch (Exception ex)
//{
// logger.LogError(ex, $"An error occurred seeding the " +
// "database with test messages. Error: {ex.Message}");
//}
}
});
}
public void Configure(IWebHostBuilder builder)
{
// Add Razor services
builder.ConfigureServices(services => RazorRuntimeCompilationMvcCoreBuilderExtensions.AddServices(services));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddScoped <NoteContext>();
// Build the service provider.
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database contexts
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var context = scopedServices.GetRequiredService <NoteContext>();
var logger = scopedServices.GetRequiredService <ILogger <NoteWebApplicationFactory <TStartup> > >();
try
{
// Seed the database with some specific test data.
context.Notes.DeleteMany(Builders <NoteUser> .Filter.Empty);
context.Notes.InsertMany(new List <NoteUser>
{
new NoteUser {
UserId = "Mukesh", Notes = new List <Note> {
new Note {
Id = 101, Category = new NoteService.Models.Category {
Id = 101, Name = "Sports", CreatedBy = "Mukesh", Description = "All about sports", CreationDate = DateTime.Now
},
Content = "Sample Note", CreatedBy = "Mukesh", Reminders = new List <NoteService.Models.Reminder> {
new NoteService.Models.Reminder {
Id = 201, Name = "Sports", CreatedBy = "Mukesh", Description = "sports reminder", CreationDate = DateTime.Now, Type = "email"
}
},
Title = "Sample", CreationDate = DateTime.Now
}
}
},
new NoteUser {
UserId = "Sachin", Notes = new List <Note> {
new Note {
Id = 101, Category = new NoteService.Models.Category {
Id = 102, Name = "Sports", CreatedBy = "Sachin", Description = "All about sports", CreationDate = DateTime.Now
},
Content = "Sample Note", CreatedBy = "Sachin", Reminders = new List <NoteService.Models.Reminder> {
new NoteService.Models.Reminder {
Id = 202, Name = "Sports", CreatedBy = "Sachin", Description = "sports reminder", CreationDate = DateTime.Now, Type = "email"
}
},
Title = "Sample", CreationDate = DateTime.Now
}
}
}
});
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred seeding the " +
"database with test messages. Error: {ex.Message}");
}
}
});
}
public static IWebHostBuilder UseStructureMap(this IWebHostBuilder builder, IContainer container)
{
return(builder.ConfigureServices(services => services.AddStructureMap(container)));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "IntegrationTests");
builder.ConfigureServices(services => {
// Create a new service provider.
#if false
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase().AddLogging()
.BuildServiceProvider();
#endif
var descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextPool <AppDbContext>));
services.Remove(descriptor);
descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextPool <AppIdentityDbContext>));
services.Remove(descriptor);
services.AddEntityFrameworkInMemoryDatabase().AddLogging();
// Add a database context (AppDbContext) using an in-memory database for testing.
services.AddDbContextPool <AppDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryAppDb");
//options.UseInternalServiceProvider(serviceProvider);
options.EnableSensitiveDataLogging();
options.EnableDetailedErrors();
options.LogTo(Console.WriteLine);
});
services.AddDbContextPool <AppIdentityDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryIdentityDb");
//options.UseInternalServiceProvider(serviceProvider);
options.EnableSensitiveDataLogging();
options.EnableDetailedErrors();
options.LogTo(Console.WriteLine);
});
services.AddScoped <SignInManager <AppUser> >();
services.AddScoped <ILogger <UserRepository> >(provider => {
ILoggerFactory loggerFactory = provider.GetRequiredService <ILoggerFactory>();
return(loggerFactory.CreateLogger <UserRepository>());
});
services.AddDistributedMemoryCache();
// Build the service provider.
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database contexts
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var appDb = scopedServices.GetRequiredService <AppDbContext>();
var identityDb = scopedServices.GetRequiredService <AppIdentityDbContext>();
var logger = scopedServices.GetRequiredService <ILogger <CustomWebApplicationFactory <TStartup> > >();
// Ensure the database is created.
appDb.Database.EnsureCreated();
identityDb.Database.EnsureCreated();
try {
// Seed the database with test data.
SeedData.PopulateTestData(identityDb);
SeedData.PopulateTestData(appDb);
} catch (Exception ex) {
logger.LogError(ex, $"An error occurred seeding the " +
$"database with test messages. Error: {ex.Message}");
}
}
});
}
void IHostingStartup.Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((serviceCollection) => {
serviceCollection.AddDevExpressBlazor();
});
}
public static IWebHostBuilder UseXPikeConsoleMetrics(this IWebHostBuilder builder) =>
builder.ConfigureServices((context, collection) =>
{
collection.UseXPikeConsoleMetrics();
collection.AddSingleton <IStartupFilter, StartupFilter>();
});
public static IWebHostBuilder ConfigureLogging(this IWebHostBuilder hostBuilder, Action <ILoggingBuilder> configureLogging)
{
return(hostBuilder.ConfigureServices(collection => collection.AddLogging(configureLogging)));
}
/// <summary>
/// Configures the port and base path the server should listen on when running behind AspNetCoreModule.
/// The app will also be configured to capture startup errors.
/// </summary>
/// <param name="hostBuilder"></param>
/// <returns></returns>
public static IWebHostBuilder UseIISIntegration(this IWebHostBuilder hostBuilder)
{
if (hostBuilder == null)
{
throw new ArgumentNullException(nameof(hostBuilder));
}
// Check if `UseIISIntegration` was called already
if (hostBuilder.GetSetting(nameof(UseIISIntegration)) != null)
{
return(hostBuilder);
}
var port = hostBuilder.GetSetting(ServerPort) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPort}");
var path = hostBuilder.GetSetting(ServerPath) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPath}");
var pairingToken = hostBuilder.GetSetting(PairingToken) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{PairingToken}");
var iisAuth = hostBuilder.GetSetting(IISAuth) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISAuth}");
var websocketsSupported = hostBuilder.GetSetting(IISWebSockets) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISWebSockets}");
bool isWebSocketsSupported;
if (!bool.TryParse(websocketsSupported, out isWebSocketsSupported))
{
// If the websocket support variable is not set, we will always fallback to assuming websockets are enabled.
isWebSocketsSupported = (Environment.OSVersion.Version >= new Version(6, 2));
}
if (!string.IsNullOrEmpty(port) && !string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(pairingToken))
{
// Set flag to prevent double service configuration
hostBuilder.UseSetting(nameof(UseIISIntegration), true.ToString());
var enableAuth = false;
if (string.IsNullOrEmpty(iisAuth))
{
// back compat with older ANCM versions
enableAuth = true;
}
else
{
// Lightup a new ANCM variable that tells us if auth is enabled.
foreach (var authType in iisAuth.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
if (!string.Equals(authType, "anonymous", StringComparison.OrdinalIgnoreCase))
{
enableAuth = true;
break;
}
}
}
var address = "http://127.0.0.1:" + port;
hostBuilder.CaptureStartupErrors(true);
hostBuilder.ConfigureServices(services =>
{
// Delay register the url so users don't accidentally overwrite it.
hostBuilder.UseSetting(WebHostDefaults.ServerUrlsKey, address);
hostBuilder.PreferHostingUrls(true);
services.AddSingleton <IServerIntegratedAuth>(_ => new ServerIntegratedAuth()
{
IsEnabled = enableAuth,
AuthenticationScheme = IISDefaults.AuthenticationScheme
});
services.AddSingleton <IStartupFilter>(new IISSetupFilter(pairingToken, new PathString(path), isWebSocketsSupported));
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});
services.Configure <IISOptions>(options =>
{
options.ForwardWindowsAuthentication = enableAuth;
});
services.AddAuthenticationCore();
});
}
return(hostBuilder);
}
public static IWebHostBuilder ConfigureLogging(this IWebHostBuilder hostBuilder, Action <WebHostBuilderContext, ILoggingBuilder> configureLogging)
{
return(hostBuilder.ConfigureServices((context, collection) => collection.AddLogging(builder => configureLogging(context, builder))));
}
public static IWebHostBuilder UseStartup(this IWebHostBuilder builder, IStartup startup) => builder .ConfigureServices(services => services.AddSingleton(startup)) .UseSetting(WebHostDefaults.ApplicationKey, startup.GetType().AssemblyQualifiedName);
