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 <ApplicationDbContext>();
context.Database.Migrate();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedAsync(userManager, context);
}
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 static async Task SeedDatabase(IWebHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogInformation("Seeding database...");
try
{
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
if (userManager.Users.Any() || roleManager.Roles.Any())
{
logger.LogDebug("User/Role data already exists.");
}
else
{
await ApplicationDbContextSeed.SeedAsync(userManager, roleManager);
logger.LogDebug("Populated AppIdentityDbContext test data.");
}
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
}
/// <summary>
/// Seed data
/// </summary>
/// <returns></returns>
public override Task InvokeSeedAsync(IServiceProvider services)
{
var seeder = new ApplicationDbContextSeed();
seeder.SeedAsync(this, services).Wait();
return(Task.CompletedTask);
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <IApplicationDbContext>();
DbInitializer.Initialize(context);
var context2 = services.GetRequiredService <PersistedGrantDbContext>();
DbInitializer.Initialize(context2);
var context3 = services.GetRequiredService <ConfigurationDbContext>();
DbInitializer.Initialize(context3);
var dbContext = services.GetRequiredService <IApplicationDbContext>();
var dateTimeService = services.GetRequiredService <IDateTime>();
ApplicationDbContextSeed.SeedAsync(dbContext, dateTimeService);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var env = services.GetService <IWebHostEnvironment>();
var context = services.GetRequiredService <ClubsContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedAsync(context);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// This will create a new scope for the logger factory and the store context objects.
using (var scope = host.Services.CreateScope())
{
// This will get the necessary services from the scope.
var services = scope.ServiceProvider;
// This will create a new instance of the logger factory service.
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
// This will create a new instance of the application db context service.
var applicationDbContext = services.GetRequiredService <ApplicationDbContext>();
// This will update the database with the latest code first migration of the dw_morgan database.
await applicationDbContext.Database.MigrateAsync();
// This will seed the database with initial data.
await ApplicationDbContextSeed.SeedAsync(applicationDbContext, loggerFactory);
}
catch (Exception ex)
{
// This will create a new logger instance for the program class.
var logger = loggerFactory.CreateLogger <Program>();
// This will log the details of the exception thrown during the database migration.
logger.LogError(ex, "An error occurred during database migration.");
}
}
await host.RunAsync();
}
/// <summary>
/// Starts the system and seeds the database
/// Runs first when the system launches
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
// Checking environments
var env = services.GetRequiredService <IWebHostEnvironment>();
if (!env.IsDevelopment() && !env.IsStaging() && !env.IsProduction())
{
// Not any of the supported environments
Environment.Exit(1);
}
// TODO: Make enviroment specific database seeding
// Database seeding
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var identityContext = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <ApplicationRole> >();
identityContext.Database.Migrate();
var financialOrganizerContext = services.GetRequiredService <FODbContext>();
financialOrganizerContext.Database.Migrate();
ApplicationDbContextSeed.SeedAsync(userManager, roleManager).Wait();
FODbContextSeed.SeedAsync(financialOrganizerContext).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured during migration");
}
}
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, IApiVersionDescriptionProvider provider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseSwagger();
app.UseSwaggerUI(options => {
foreach (var desc in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{desc.GroupName}/swagger.json", desc.GroupName.ToUpperInvariant());
}
options.RoutePrefix = "";
});
app.UseRouting();
app.UseCors(x => x.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
ApplicationDbContextSeed.SeedAsync(app).Wait();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedEssentialsAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedAsync(userManager, context);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static async Task <int> Main(string[] args)
{
ConfigureLogging();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var dataContext = services.GetRequiredService <ApplicationDbContext>();
await dataContext.Database.MigrateAsync();
await ApplicationDbContextSeed.SeedAsync(dataContext);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, $"Error while Migrating or Seeding the Database: {ex.Message}");
return(1);
}
}
await host.RunAsync();
return(0);
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var identityContext = services.GetRequiredService <ApplicationDbContext>();
identityContext.Database.Migrate();
//Populate Data
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var RolManager = services.GetRequiredService <RoleManager <ApplicationRol> >();
await ApplicationDbContextSeed.SeedAsync(userManager, RolManager);
await ApplicationDbContextSeed.SeedMainDataAsync(identityContext);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or initializing the database.");
}
}
host.Run();
}
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>();
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
await context.Database.MigrateAsync();
await ApplicationDbContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
/// <summary>
/// Restaurar la base de datos en cada test.
/// De lo contrario da problemas con la autenticación.
/// </summary>
private async Task RestoreDatabase()
{
var dbContext = ServiceProvider.GetRequiredService <ApplicationDbContext>();
await dbContext.Database.EnsureDeletedAsync();
await ApplicationDbContextSeed.SeedAsync(ServiceProvider);
}
public static void 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 db = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <IdentityUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
ApplicationDbContextSeed.SeedAsync(db, userManager, roleManager).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the database");
}
}
host.Run();
}
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>();
var configuration = services.GetRequiredService <IConfiguration>();
var seedSettings = configuration.Get <DatabaseSeedSettings>();
try
{
var catalogContext = services.GetRequiredService <ApplicationDbContext>();
await ApplicationDbContextSeed.SeedAsync(catalogContext, loggerFactory, seedSettings.DatabaseSeed).ConfigureAwait(false);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("System", LogEventLevel.Information)
.MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.File("web_api_log.txt")
.WriteTo.Console(
outputTemplate:
"[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}",
theme: AnsiConsoleTheme.Literate)
.CreateLogger();
try
{
var seed = args.Contains("/seed");
if (seed)
{
args = args.Except(new[] { "/seed" }).ToArray();
}
var host = CreateHostBuilder(args).Build();
if (seed)
{
using var scope = host.Services.CreateScope();
Log.Information("Seeding database...");
var context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
await context.Database.MigrateAsync();
await ApplicationDbContextSeed.SeedAsync(scope.ServiceProvider);
Log.Information("Done seeding database.");
return;
}
Log.Information("Starting host...");
await host.RunAsync();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// Add database name for testing
builder.ConfigureServices(services =>
{
// Create a new service provider.
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase()
.BuildServiceProvider();
// Add a database context (AppDbContext) using an in-memory database for testing.
services.AddDbContext <ApplicationDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryAppDb");
options.UseInternalServiceProvider(serviceProvider);
});
// 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 <ApplicationDbContext>();
var env = scopedServices.GetService <IHostingEnvironment>();
var logger = scopedServices.GetService <ILogger <ApplicationDbContextSeed> >();
var settings = scopedServices.GetService <IOptions <Identity.API.AppSettings> >();
var contextSeed = new ApplicationDbContextSeed();
context.Database.EnsureCreated();
try
{
contextSeed.SeedAsync(context, env, logger, settings).Wait();
// create roles and set role into users
contextSeed.CreateUserRoles(serviceProvider).Wait();
// Create claims
contextSeed.InitUserClaims(serviceProvider).Wait();
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred seeding the " +
"database with test messages. Error: {ex.Message}");
}
}
});
}
/// <summary>
/// Configuration of the Host.
/// </summary>
/// <param name="builder">Host provider.</param>
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder = builder ?? throw new ArgumentNullException(nameof(builder));
builder.UseEnvironment("Testing");
builder.ConfigureServices(services => {
services.AddEntityFrameworkInMemoryDatabase();
var provider = services
.AddEntityFrameworkInMemoryDatabase()
.BuildServiceProvider();
services.AddDbContext <ApplicationDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDbForTesting");
options.UseInternalServiceProvider(provider);
});
services.AddDbContext <ApplicationDbContext>(options =>
{
options.UseInMemoryDatabase("Identity");
options.UseInternalServiceProvider(provider);
});
var sp = services.BuildServiceProvider();
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <ApplicationDbContext>();
var loggerFactory = scopedServices.GetRequiredService <ILoggerFactory>();
var logger = scopedServices.GetRequiredService <ILogger <WebTestFixture> >();
db.Database.EnsureCreated();
try
{
var userManager = scopedServices.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = scopedServices.GetRequiredService <RoleManager <IdentityRole> >();
ApplicationDbContextSeed.SeedAsync(userManager, roleManager, db).Wait();
}
catch (Exception ex)
{
logger.LogError(ex, $"An error occurred seeding the database with test messages. Error: {ex.Message}");
}
}
});
}
/// <summary>
/// Fill database with initial date.
/// </summary>
/// <param name="serviceProvider">Service provider.</param>
public static void Initialize(IServiceProvider serviceProvider)
{
try
{
var contextOptions = serviceProvider.GetRequiredService <DbContextOptions <ApplicationDbContext> >();
var userManager = serviceProvider.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = serviceProvider.GetRequiredService <RoleManager <IdentityRole> >();
using var applicationContext = new ApplicationDbContext(contextOptions);
ApplicationDbContextSeed.SeedAsync(userManager, roleManager, applicationContext).GetAwaiter().GetResult();
Log.Information(InitializationConstants.SeedSuccess);
}
catch (Exception ex)
{
Log.Error(ex, InitializationConstants.SeedError);
}
}
public static void CreateIfDbNotExists(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
ApplicationDbContextSeed.SeedAsync(context, loggerFactory, userManager, roleManager).GetAwaiter().GetResult();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>(); //Logging
try
{
var dbContext = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(dbContext).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
var pcontext = services.GetRequiredService <PersistedGrantDbContext>();
var configContext = services.GetRequiredService <ConfigurationDbContext>();
var usermanagement = services.GetRequiredService <UserManager <ApplicationUser> >();
var rolemanagement = services.GetRequiredService <RoleManager <IdentityRole> >();
if (pcontext.Database.IsSqlServer())
{
pcontext.Database.Migrate();
}
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedAsync(context, usermanagement, rolemanagement);
if (configContext.Database.IsSqlServer())
{
configContext.Database.Migrate();
}
}
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();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ApplicationDbContext dataContext, IAppLogger <ApplicationDbContext> appLogger)
{
dataContext.Database.Migrate();
try
{
ApplicationDbContextSeed.SeedAsync(dataContext, appLogger).Wait();
}
catch (Exception ex)
{
appLogger.LogError(ex.Message.ToString());
}
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("./v1/swagger.json", "ToDo App API");
});
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseStaticFiles();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
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 <ApplicationDbContext>();
await ApplicationDbContextSeed.SeedAsync(context);
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedUserAsync(userManager, roleManager);
}
catch (Exception ex)
{
ex.ToString();
}
}
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, IServiceProvider serviceProvider, ApplicationDbContext context)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
//role en usermanager in de pipeline
RoleManager <Role> roleManager = serviceProvider.GetRequiredService <RoleManager <Role> >();
UserManager <User> userManager = serviceProvider.GetRequiredService <UserManager <User> >();
(ApplicationDbContextSeed.SeedAsync(context, env, roleManager, userManager)).Wait();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapRazorPages();
});
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <BlogDbContext>();
await BlogDbContextSeed.SeedAsync(context, loggerFactory);
var appContext = services.GetRequiredService <ApplicationDbContext>();
await ApplicationDbContextSeed.SeedAsync(appContext, loggerFactory);
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e, "An error occurred seeding the DB.");
}
host.Run();
}
