public static async Task <IHost> CreateDatabase <T>(this IHost webHost) where T : DbContext
{
using (var scope = webHost.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var db = services.GetRequiredService <T>();
await db.Database.MigrateAsync();
var roleManager = scope.ServiceProvider.GetRequiredService <RoleManager <IdentityRole> >();
if (!await roleManager.RoleExistsAsync(Roles.Admin))
{
var adminRole = new IdentityRole(Roles.Admin);
await roleManager.CreateAsync(adminRole);
}
if (!await roleManager.RoleExistsAsync(Roles.User))
{
var userRole = new IdentityRole(Roles.User);
await roleManager.CreateAsync(userRole);
}
var userManager = scope.ServiceProvider.GetRequiredService <UserManager <User> >();
await DatabaseContextSeed.SeedDefaultAdmin(userManager, scope, roleManager);
}
catch
{
//TODO: log error
}
}
return(webHost);
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
// temporary code blockes
try
{
var contextIdentity = services.GetRequiredService <DatabaseContext>();
var userManager = services.GetRequiredService <UserManager <AppUser> >();
await contextIdentity.Database.MigrateAsync();
await DatabaseIdentityContextSeed.SeedUserAsync(userManager, loggerFactory);
var context = services.GetRequiredService <DatabaseContext>();
await context.Database.MigrateAsync();
await DatabaseContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args)
.UseUrls("https://localhost:6001/")
.Build();
//.Run();
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
// Seed InMemory when in Development
if (environment == EnvironmentName.Development)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var databaseContext = services.GetRequiredService <DatabaseContext>();
DatabaseContextSeed.SeedAsync(databaseContext).Wait();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory logger)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.Development.json")
.Build();
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.CreateLogger();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
try
{
using (var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope())
{
var dbContext = serviceScope.ServiceProvider.GetRequiredService <DatabaseContext>();
if (env.IsDevelopment())
{
//dbContext.Database.EnsureDeleted();
//Log.Logger.ForContext(typeof(Program)).Information("Database EnsureDeleted done");
}
dbContext.Database.EnsureCreated();
Log.Logger.ForContext(typeof(Program)).Information("Database EnsureCreated done");
DatabaseContextSeed dbSeed = new DatabaseContextSeed(logger, dbContext);
dbSeed.SeedUsers();
}
}
catch (Exception ex)
{
Log.Logger.ForContext(typeof(Program)).Error(ex, "ERROR ENSURE CREATED DATABASE");
throw ex;
}
}
public static async Task MigrateAsync(IServiceProvider services)
{
var context = services.GetRequiredService <DatabaseContext>();
if (context.Database.IsSqlServer())
{
await context.Database.MigrateAsync();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await DatabaseContextSeed.SeedDatabaseAsync(context, userManager);
}
private void InitializeDatabase(IApplicationBuilder app)
{
using var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope();
var persistedGrantDbContext = serviceScope.ServiceProvider.GetRequiredService <PersistedGrantDbContext>();
var configurationContext = serviceScope.ServiceProvider.GetRequiredService <ConfigurationDbContext>();
var databaseContext = serviceScope.ServiceProvider.GetRequiredService <DatabaseContext>();
// Migrate
persistedGrantDbContext.Database.Migrate();
configurationContext.Database.Migrate();
databaseContext.Database.Migrate();
DatabaseContextSeed.SeedAsync(databaseContext).Wait();
ConfigurationDbContextSeed.SeedAsync(configurationContext).Wait();
}
private static void SeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var databaseContext = services.GetRequiredService <DatabaseContext>();
DatabaseContextSeed.SeedAsync(databaseContext, loggerFactory).Wait();
}
catch (Exception exception)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(exception, "An error occurred seeding the DB.");
}
}
}
protected override void Seed(DatabaseContext context)
{
base.Seed(context);
DatabaseContextSeed.Seed(context);
}
