public static void Main(string[] args)
{
var builder = CreateWebHostBuilder(args);
string env = "Development";
if (args.Any())
{
env = args[0];
}
builder.UseEnvironment(env);
var host = builder.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <AppDbContext>();
SeedData.PopulateTestData(context);
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
AppIdentityDbContextSeed.SeedAsync(userManager, roleManager).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
host.Run();
}
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 appContext = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(appContext, loggerFactory)
.Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).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 = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var catalogContext = services.GetRequiredService <CatalogContext>();
catalogContext.Database.MigrateAsync().Wait();
var searchSvc = services.GetRequiredService <SearchService>();
var storageSvc = services.GetRequiredService <ICloudStorageService>();
CatalogContextSeed.SeedAsync(catalogContext, searchSvc, storageSvc, loggerFactory).Wait();
var appIdentityDbContext = services.GetRequiredService <AppIdentityDbContext>();
appIdentityDbContext.Database.MigrateAsync().Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).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 = CreateWebHostBuilder(args).Build();
var logger = host.Services.GetRequiredService <ILogger <Program> >();
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 userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
logger.LogInformation("Log Message: Seeding AppIdentityDbContext");
}
catch (Exception)
{
logger.LogError($"InMemory database seeding failed. at {DateTime.Now}.");
throw;
}
}
}
host.Run();
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.RollingFile("Logs/web-ui.log")
.CreateLogger();
var host = CreateWebHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var userManager = services.GetRequiredService <UserManager <IdentityUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
var context = scope.ServiceProvider.GetService <AppDataDbContext>();
AppDataDbContextSeed.Seed(context);
}
catch (Exception ex)
{
Log.Error(ex, "Fejl ved opstart af Tidsregistrering Web UI");
}
}
host.Run();
}
private static async Task SeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogInformation("Seeding database...");
try
{
var context = services.GetRequiredService <AppDbContext>();
if (context.Questions !.Any())
{
logger.LogDebug("Database already has data in it.");
}
else
{
SeedData.PopulateTestData(context);
logger.LogDebug("Populated AppDbContext test data.");
}
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 AppIdentityDbContextSeed.SeedAsync(userManager, roleManager);
logger.LogDebug("Populated AppIdentityDbContext test data.");
}
}
protected HttpClient GetClient()
{
var startupAssembly = typeof(Startup).GetTypeInfo().Assembly;
_contentRoot = GetProjectPath("src", "WebRazorPages");
var builder = new WebHostBuilder()
.UseContentRoot(_contentRoot)
.UseEnvironment("Testing")
.UseStartup <Startup>();
var server = new TestServer(builder);
// seed data
using (var scope = server.Host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
var catalogContext = services.GetRequiredService <CatalogContext>();
CatalogContextSeed.SeedAsync(catalogContext, loggerFactory)
.Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
}
return(server.CreateClient());
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
// TwoNoteContext Seed.
var context = services.GetService <TwoNoteContext>();
DbSeed.SeedAsync(context).Wait();
// AppIdentityDbContext Seed.
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured while 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>();
try
{
var context = services.GetRequiredService <AppIdentityDbContext>();
var environment = services.GetRequiredService <IWebHostEnvironment>();
AppIdentityDbContextSeed.EnsureDatabaseMigrations(context);
await AppIdentityDbContextSeed.EnsureRoleAdminCreated(services);
await AppIdentityDbContextSeed.EnsureUserAdminCreated(services, environment.IsDevelopment());
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var damaContext = services.GetRequiredService <DamaContext>();
DamaContextSeed.EnsureDatabaseMigrations(damaContext);
await DamaContextSeed.SeedAsync(damaContext, loggerFactory, null, environment.IsDevelopment());
}
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 = CreateWebHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var serviceConfig = services.GetService <IConfiguration>();
var catalogContext = services.GetRequiredService <CatalogContext>();
CatalogContextSeed.StorageAccountConnStr = GetAppSettingsConfigValue(serviceConfig, "appsettings.Development.json", "eShopStorageAccountCS");
var dbSeed = services.GetRequiredService <IDbSeed>();
CatalogContextSeed.SeedAsync(catalogContext, loggerFactory, dbSeed).Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).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 = CreateWebHostBuilder(args) // @issue@I02
.Build(); // @issue@I02
using (var scope = host.Services.CreateScope()) // @issue@I02
{
var services = scope.ServiceProvider; // @issue@I02
var loggerFactory = services.GetRequiredService <ILoggerFactory>(); // @issue@I02
try
{
var catalogContext = services.GetRequiredService <CatalogContext>(); // @issue@I02
CatalogContextSeed.SeedAsync(catalogContext, loggerFactory) // @issue@I02
.Wait(); // @issue@I02
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); // @issue@I02
AppIdentityDbContextSeed.SeedAsync(userManager).Wait(); // @issue@I02
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>(); // @issue@I02
logger.LogError(ex, "An error occurred seeding the DB."); // @issue@I02
}
}
host.Run(); // @issue@I02
}
// 27-3 don't forget to change to async and return type Task at main when using calling async methods at main
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// 27-1 access data context; enable auto migrations.
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
// 27 -2 get StoreContext from Container and call migration programatically.
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
// 28-2 call seed data
await StoreContextSeed.SeedAsync(context, loggerFactory);
// 167-1 Add Identity to Program class
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
// don't forget to call .Run();
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
using (var context = services.GetService <AppDbContext>())
{
context.Database.Migrate();
AppDbContextSeed.Seed(context);
}
using (var context = services.GetService <AppIdentityDbContext>())
{
context.Database.Migrate();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await AppIdentityDbContextSeed.SeedAsync(userManager, roleManager);
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope()) //any code that runs inside of using statement is disposed after the execution of the methods inside
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <ArtMiraDbContext>();
await context.Database.MigrateAsync();
await ArtClassContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
host.Run();
}
}
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run(); // prev code
var host = CreateHostBuilder(args).Build();
// following code is for creating migration on startup and logging.
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync(); // this will apply any pending migration if pending and create db if not exists.
// seeding data
await StoreContextSeed.SeedAsync(context, loggerFactory);
// identity sees code
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync(); // here identity db will be created
await AppIdentityDbContextSeed.SeedUsersAsync(userManager); // addind seed for user
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured on migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
// CreateHostBuilder(args).Build().Run();
//following chaange has been made to enable migration on app startup
//pending migrations if any will be executed ..if database not present then will be created
//WE NEED TO MAKE THE MAIN METHOD ASYNC FOR THIS AS WE WIL AWAIT FOR MIGRATEASYNC FUNCTION
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 <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddEntityFrameworkInMemoryDatabase();
// Create a new service provider.
var provider = services
.AddEntityFrameworkInMemoryDatabase()
.BuildServiceProvider();
// Add a database context (ApplicationDbContext) using an in-memory
// database for testing.
services.AddDbContext <CatalogContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDbForTesting");
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 <CatalogContext>();
var loggerFactory = scopedServices.GetRequiredService <ILoggerFactory>();
var logger = scopedServices
.GetRequiredService <ILogger <CustomWebApplicationFactory <TStartup> > >();
// 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 static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// apply migrations or database if it does not exist
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
// seed product data
await StoreContextSeed.SeedAsync(context, loggerFactory);
// seed user
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e, "An error occured during migration");
}
await host.RunAsync();
}
public static async Task Main(string[] args)
{
// Apply migration and create database at startup
var host = CreateHostBuilder(args).Build();
// using means any code runs inside of this is going to be disposed once finished
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// using mark a scope handled like Spring Bean
// seeding database like Spring CommandlineRunner
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
// create the database if not exist
await context.Database.MigrateAsync();
// seeding database with StoreContextSeed class
await StoreContextSeed.SeedAsync(context, loggerFactory);
// IdentityBuilder implementation
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
#region 3.27 Applying migrations and updating database
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 <StoreContext>();
await context.Database.MigrateAsync(); //applyes pending migrations
//3.28.2 Adding Seed method ->
await StoreContextSeed.SeedAsync(context, loggerFactory);
#region 15.167 Seeding data and automatic migrations for identity -> AccountController
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
#endregion
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
#endregion
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
// Получение услуг (service)
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try {
var context = services.GetRequiredService <StoreContext>();
// Применяем любые ожидающие миграции для контекста к базе данных
// Он создаст базу данных, когда она не существует.
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
var roleManager = services.GetRequiredService <RoleManager <AppRole> >();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager, roleManager);
} catch (Exception ex) {
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
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 <STContext>();
await context.Database.MigrateAsync();
await STContextSeed.SeedAsync(context);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContex = services.GetRequiredService <AppIdentityDbContext>();
await identityContex.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUderAsync(userManager);
}catch (Exception ex)
{
}
}
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 dbContext = services.GetRequiredService <ApplicationDbContext>();
await dbContext.Database.MigrateAsync();
await AppDbContextSeed.SeedAsync(dbContext, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var roleManager = services.GetRequiredService <RoleManager <AppRole> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError($"Could not create or migrate database, see full error: {ex}");
}
}
host.Run();
}
public static void 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 <AppIdentityDbContext>();
AppIdentityDbContextSeed.EnsureDatabaseMigrations(context);
AppIdentityDbContextSeed.EnsureRoleAdminCreated(services).Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager, context);
var groceryContext = services.GetRequiredService <GroceryContext>();
GroceryContextSeed.EnsureDatabaseMigrations(groceryContext);
GroceryContextSeed.SeedAsync(groceryContext).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
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 command = services.GetRequiredService <EcommerceCommandContext>();
await EnsureSeed.CommandSeed(command, loggerFactory);
var query = services.GetRequiredService <EcommerceQueryContext>();
await EnsureSeed.QuerySeed(query, loggerFactory);
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await AppIdentityDbContextSeed.SeedAsync(userManager, roleManager);
loggerFactory.CreateLogger <Program>().LogInformation("Database Seed with scucess");
}
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)
{
var host = CreateHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var catalogContext = services.GetRequiredService <CatalogContext>();
await CatalogContextSeed.SeedAsync(catalogContext, loggerFactory);
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await AppIdentityDbContextSeed.SeedAsync(userManager, roleManager);
}
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)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <AppDbContext>();
// context.Database.Migrate();
context.Database.EnsureCreated();
SeedData.Initialize(services);
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
identityContext.Database.EnsureCreated();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await AppIdentityDbContextSeed.SeedAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
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 <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
protected HttpClient GetClient()
{
var startupAssembly = typeof(Startup).GetTypeInfo().Assembly;
var contentRoot = GetProjectPath("src", startupAssembly);
var builder = new WebHostBuilder()
.UseContentRoot(contentRoot)
.ConfigureTestServices(InitializeServices)
.UseStartup <Startup>()
.UseStructureMap()
.UseConfiguration(new ConfigurationBuilder()
.SetBasePath(contentRoot)
.AddJsonFile("appsettings.json")
.Build());
var server = new TestServer(builder);
using (var scope = server.Host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
return(server.CreateClient());
}
