public static async 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>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleCityDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args)
.ConfigureLogging((hostingContext, logging) => {
logging.AddFile("logs/homiepagesApi-{Date}.txt");
}).Build();
using (var scope = host.Services.CreateScope()) {
var services = scope.ServiceProvider;
try {
var context = services.GetRequiredService <ApplicationDbContext> ();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> > ();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> > ();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
} catch (Exception ex) {
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> > ();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
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>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
throw;
}
}
await host.RunAsync();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var serivces = scope.ServiceProvider;
try
{
var dbContext = serivces.GetRequiredService <ApplicationDbContext>();
dbContext.Database.Migrate();
var userManager = serivces.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = serivces.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(dbContext);
}
catch (Exception ex)
{
var logger = serivces.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "Error 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;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
await context.Database.MigrateAsync();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "Ocorreu um erro durante a migração ou propagação do banco de dados.");
throw;
}
}
await host.RunAsync();
}
public static async Task Main(string[] args)
{
var host = BuildWebHost(args);
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
var configuration = host.Services.GetRequiredService <IConfiguration>();
var myLogFilePath = configuration.GetValue <string>("MyLogFilePath");
var logFilePath = myLogFilePath.IndexOf(":") > 0 ? myLogFilePath
: Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, myLogFilePath));
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Literate)
.WriteTo.File(
logFilePath,
rollingInterval: RollingInterval.Day,
fileSizeLimitBytes: 1_000_000,
rollOnFileSizeLimit: true,
shared: true,
flushToDiskInterval: TimeSpan.FromSeconds(5))
.CreateLogger();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
SerilogLog.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(LevelSwitch)
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.File(
"logs/log.txt",
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}",
rollingInterval: RollingInterval.Day,
retainedFileCountLimit: 7,
rollOnFileSizeLimit: true,
shared: true)
.CreateLogger();
try
{
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.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception exp)
{
SerilogLog.Error(exp, "An error occurred while migrating or seeding the database.");
}
}
await host.RunAsync();
}
catch (System.Exception exp)
{
SerilogLog.Fatal(exp, "Host terminated unexpectedly");
}
finally
{
SerilogLog.Information("Ending the web host!");
SerilogLog.CloseAndFlush();
}
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder
.ConfigureServices(async 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("LibraryDbTesting");
options.UseInternalServiceProvider(serviceProvider);
});
//services.AddScoped<IDomainEventDispatcher, NoOpDomainEventDispatcher>();
// Build the service provider.
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database
// context (AppDbContext).
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var context = scopedServices.GetRequiredService <ApplicationDbContext>();
var logger = scopedServices
.GetRequiredService <ILogger <CustomWebApplicationFactory <TStartup> > >();
// Ensure the database is created.
context.Database.EnsureCreated();
var userManager = scopedServices.GetRequiredService <UserManager <ApplicationUser> >();
try
{
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
// Seed the database with test data.
ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred seeding the " +
$"database with test messages. Error: {ex.Message}");
}
}
});
}
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>();
if (context.Database.IsMySql())
{
{
context.Database.Migrate();
}
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.CreateLogger();
try
{
var context = services.GetRequiredService<ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var seedData = new SeedDataModel
{
FirstName = configuration.GetSection("SeedData:FirstName").Value,
Email = configuration.GetSection("SeedData:Email").Value,
UserPassword = configuration.GetSection("SeedData:UserPassword").Value,
UserRole = configuration.GetSection("SeedData:UserRole").Value,
UserRoleNormalized = configuration.GetSection("SeedData:UserRoleNormalized").Value,
DefaultRoleName = configuration.GetSection("SeedData:DefaultRoleName").Value,
DefaultRoleNormalizedName = configuration.GetSection("SeedData:DefaultRoleNormalizedName").Value,
};
var userManager = services.GetRequiredService<UserManager<AppUser>>();
var roleManager = services.GetRequiredService<RoleManager<AppRole>>();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager, seedData);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
Log.Logger.Error(ex, "An error occurred while migrating or seeding the database");
throw;
}
}
await host.RunAsync();
}
private static void SeedPredefinedData(IServiceScope scope)
{
try
{
var context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = scope.ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >();
ApplicationDbContextSeed.SeedDefaultUserAsync(userManager).GetAwaiter().GetResult();
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// migrate the database. Best practice = in Main, using service scope
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
// for demo purposes, delete the database & migrate on startup so
// we can start with a clean slate
//context.Database.EnsureDeleted();
//context.Database.Migrate();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating the database.");
}
}
// run the web app
await host.RunAsync();
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
try
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
await context.Database.MigrateAsync();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.MSSqlServer(context.Database.GetConnectionString(), new MSSqlServerSinkOptions()
{
TableName = "Log", AutoCreateSqlTable = true
})
.CreateLogger();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex);
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
