public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
//Create instances of logger class
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <DataContext>();
await context.Database.MigrateAsync();
//await DataContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <IdentityContext>();
await identityContext.Database.MigrateAsync();
await IdentityContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <IdentityContext>();
context.Database.Migrate();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await IdentityContextSeed.SeedAsync(userManager);
var applicationContext = services.GetRequiredService <ApplicationDbContext>();
await ApplicationDbContextSeed.SeedAsync(applicationContext);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
}
}
await host.RunAsync();
}
private async static Task CreateDbIfNotExists(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var contextApp = services.GetRequiredService <ApplicationDbContext>();
contextApp.Database.EnsureCreated();
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await IdentityContextSeed.SeedRolesAsync(userManager, roleManager);
await IdentityContextSeed.SeedRootAsync(userManager, roleManager);
var contextGamesroom = services.GetRequiredService <GamesroomDbContext>();
contextGamesroom.Database.EnsureCreated();
var contextPilkonPopulationControl = services.GetRequiredService <PilkonPopulationControlDbContext>();
contextPilkonPopulationControl.Database.EnsureCreated();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred creating the DB.");
}
}
}
public static async Task Main(string[] args)
{
var host = CreateWebHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var identityContext = services.GetRequiredService <CollegeIdentityDbContext>();
var identityManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await IdentityContextSeed.SeedAsync(identityContext, identityManager, loggerFactory);
var collegeContext = services.GetRequiredService <CollegeContext>();
await CollegeContextSeed.SeedAsync(collegeContext, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
/// <summary>
/// Build services factory.
/// </summary>
/// <param name="host">Application Host.</param>
public static void Build(IHost host)
{
host = host ?? throw new ArgumentNullException(nameof(host));
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
RuntimeMigrations.Initialize(services);
IdentityContextSeed.Initialize(services);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
InitializeDatabase(app);
IdentityContextSeed.EnsureSeedData(app);
app.UseCors("AllowAllRequest");
app.UseIdentityServer();
app.UseStaticFiles();
app.UseMvcWithDefaultRoute();
}
public static void Main(string[] args)
{
CreateWebHostBuilder(args).Build().MigrateDbContext <IdentityContext>((context, services) =>
{
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("BuildWebHost");
try
{
IdentityContextSeed.SeedAsync(context, loggerFactory).Wait();
}
catch (Exception exception)
{
logger.LogError(exception, "An error occurred seeding the DB.");
}
}).Run();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseEnvironment("Testing");
builder.ConfigureServices(services =>
{
services.AddEntityFrameworkInMemoryDatabase();
var provider = services
.AddEntityFrameworkInMemoryDatabase()
.BuildServiceProvider();
services.AddDbContext <ApplicationContext>(options =>
{
options.UseInMemoryDatabase("DBForTesting");
options.UseInternalServiceProvider(provider);
});
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationContext>();
var sp = services.BuildServiceProvider();
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <ApplicationContext>();
db.Database.EnsureCreated();
try
{
var userManager = scopedServices.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = scopedServices.GetRequiredService <RoleManager <IdentityRole> >();
IdentityContextSeed.SeedAsync(userManager, roleManager).Wait();
ApplicationContextSeed.SeedAsync(db, userManager, "/img/example_image.jpg").Wait();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
});
}
