public async void NoTrackingTest() { using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); Item item = await context.Items.AsTracking().Where(i => i.Name == "5-MTHF").FirstOrDefaultAsync(); Assert.Empty(item.MetaData); item.Name += " - updated"; Assert.Equal(EntityState.Modified, context.Entry(item).State); int changes = await context.SaveChangesAsync(); Assert.Equal(1, changes); Assert.Equal(EntityState.Unchanged, context.Entry(item).State); } using (Context context2 = Context.ContextDesignFactory.CreateDbContext(Config)) { Item item2 = await context2.Items.Where(i => i.Name == "5-MTHF - updated").FirstOrDefaultAsync(); Assert.NotNull(item2); await context2.Database.EnsureDeletedAsync(); } }
public static async Task Main(string[] args) { var host = CreateHostBuilder(args).Build(); await DataHelper.ManageDataAsync(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 <FPUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var imageService = services.GetRequiredService <IImageService>(); await ContextSeed.SeedRolesAsync(roleManager); await ContextSeed.SeedDefaultUserAsync(userManager, imageService); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occurred seeding the DB."); } } host.Run(); }
public async void MetaDataTest() { using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); } using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { List <Brand> brands = await context.Brands.AsTracking().ToListAsync(); List <Vendor> vendors = await context.Vendors.AsTracking().ToListAsync(); List <ROL.Services.Catalog.Domain.Unit> units = await context.Units.AsTracking().ToListAsync(); List <Category> categories = await context.Categories.AsTracking().ToListAsync(); Item item = await context.Items.AsTracking() .Include(i => i.ItemCategories) .Include(i => i.Variants) .Where(i => i.Name == "5-MTHF") .FirstOrDefaultAsync(); Assert.Empty(item.MetaData); item.MetaData.Add("Test1", "1"); item.MetaData.Add("Test2", "2"); item.MetaData.Add("Test3", "3"); Assert.True(context.Entry(item).Property(p => p.MetaData).IsModified, "Property is modified"); Assert.Equal(EntityState.Modified, context.Entry(item).State); int changes = await context.SaveChangesAsync(); Assert.Equal(EntityState.Unchanged, context.Entry(item).State); } using (Context context2 = Context.ContextDesignFactory.CreateDbContext(Config)) { List <Brand> brands = await context2.Brands.AsTracking().ToListAsync(); List <Vendor> vendors = await context2.Vendors.AsTracking().ToListAsync(); List <ROL.Services.Catalog.Domain.Unit> units = await context2.Units.AsTracking().ToListAsync(); List <Category> categories = await context2.Categories.AsTracking().ToListAsync(); Item item2 = await context2.Items .Include(i => i.ItemCategories) .Include(i => i.Variants) .Where(i => i.Name == "5-MTHF") .FirstOrDefaultAsync(); Assert.Equal("1", item2.MetaData["Test1"]); Assert.Equal("2", item2.MetaData["Test2"]); Assert.Equal("3", item2.MetaData["Test3"]); await context2.Database.EnsureDeletedAsync(); } }
public async void Speed3() { using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); } using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { List <Brand> brands = await context.Brands.AsTracking().ToListAsync(); List <Vendor> vendors = await context.Vendors.AsTracking().ToListAsync(); List <ROL.Services.Catalog.Domain.Unit> units = await context.Units.AsTracking().ToListAsync(); List <Category> categories = await context.Categories.AsTracking().ToListAsync(); List <Item> item = await context.Items.AsTracking() .Include(i => i.ItemCategories) .Include(i => i.Variants) .ToListAsync(); Assert.NotNull(item[0].Brand); Assert.NotNull(item[0].ItemCategories[0].Category); Assert.NotNull(item[0].Variants[0].Unit); Assert.NotNull(item[0].Variants[0].Vendor); await context.Database.EnsureDeletedAsync(); } }
public static async Task Main(string[] args) { IHost host = CreateHostBuilder(args).Build( ); await PostgresSwapper .ManageDataAsync(host) .ConfigureAwait(false); await host .RunAsync( ) .ConfigureAwait(false); using IServiceScope scope = host.Services.CreateScope( ); IServiceProvider services = scope.ServiceProvider; ILoggerFactory loggerFactory = services.GetRequiredService <ILoggerFactory>( ); try { ApplicationDbContext context = services.GetRequiredService <ApplicationDbContext>( ); UserManager <HeimdallUser> userManager = services.GetRequiredService <UserManager <HeimdallUser> >( ); RoleManager <IdentityRole> roleManager = services.GetRequiredService <RoleManager <IdentityRole> >( ); await ContextSeed.RunSeedMethodsAsync(context, roleManager, userManager).ConfigureAwait(false); } catch (Exception ex) { ILogger <Program> logger = loggerFactory.CreateLogger <Program>( ); logger.LogError(ex, "An error occurred seeding the DB."); } await host.RunAsync( ).ConfigureAwait(false); }
//dodavanje podataka prilikom pokretanja aplikacije 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 <Korisnik> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.Administratori(userManager, roleManager); await ContextSeed.Predavaci(userManager, roleManager); //await ContextSeed.Polaznik(userManager,roleManager); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "Došlo je do pogreške prilikom postavljanja DB-a."); } } 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 { System.Diagnostics.Debug.WriteLine("Program Started"); var context = services.GetRequiredService <SeniorLibraryContext>(); var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.SeedSuperAdminAsync(userManager, roleManager); //Must have users.json in project folder! await ContextSeed.AddUserAsync(userManager, roleManager); await ContextSeed.AddBookAsync(context); } 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 context = services.GetRequiredService <FagElGamousContext>(); var userManager = services.GetRequiredService <UserManager <AppUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.SeedAdminAsync(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; var loggerFactory = services.GetRequiredService <ILoggerFactory>(); try { var context = scope.ServiceProvider.GetService <RealStateDbContext>(); context.Database.EnsureDeleted(); context.Database.Migrate(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(roleManager); var userManager = services.GetRequiredService <UserManager <AppUser> >(); await ContextSeed.SeedUsersAsync(userManager); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occurred while migrating the database."); } } // run the web app host.Run(); }
//Handles the Migration Programmatic public static async Task ManageDataAsync(IHost host) { try { //This technique is used to obtain references to services //Normally I would just inject these services but you cant use a constructor in a static class. using var svcScope = host.Services.CreateScope(); var svcProvider = svcScope.ServiceProvider; //The services will run your migrations var dbContextSvc = svcProvider.GetRequiredService <ApplicationDbContext>(); await dbContextSvc.Database.MigrateAsync(); var userManager = svcProvider.GetRequiredService <UserManager <FPUser> >(); var roleManager = svcProvider.GetRequiredService <RoleManager <IdentityRole> >(); var imageService = svcProvider.GetRequiredService <IImageService>(); await ContextSeed.SeedRolesAsync(roleManager); await ContextSeed.SeedDefaultUserAsync(userManager, imageService); //var settings = svcProvider.GetRequiredService<IOptions<AdminSettings>>(); //await SeedDataAsync(seedConfigSvc); } catch (PostgresException ex) { Console.WriteLine($"Exception while running Manage Data => {ex}"); } }
public async void Speed2() { using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); } using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { List <Item> item = await context.Items.AsTracking() .Include(i => i.Brand) .Include(i => i.ItemCategories) .ThenInclude(t => t.Category) .Include(i => i.Variants) .ThenInclude(v => v.Vendor) .Include(i => i.Variants) .ThenInclude(v => v.Unit) .ToListAsync(); Assert.NotNull(item[0].Brand); Assert.NotNull(item[0].ItemCategories[0].Category); Assert.NotNull(item[0].Variants[0].Unit); Assert.NotNull(item[0].Variants[0].Vendor); await context.Database.EnsureDeletedAsync(); } }
public static async Task ManageData(IHost host) { try { // This technique is used to obtain references to services // normally I would just inject these services but you cant use a constructor in a static class using var svcScope = host.Services.CreateScope(); var svcProvider = svcScope.ServiceProvider; //The service will run your migrations var dbContextSvc = svcProvider.GetRequiredService <ApplicationDbContext>(); await dbContextSvc.Database.MigrateAsync(); var services = svcScope.ServiceProvider; var context = services.GetRequiredService <ApplicationDbContext>(); var userManager = services.GetRequiredService <UserManager <FPUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var fileService = services.GetRequiredService <IFPFileService>(); var configuration = services.GetRequiredService <IConfiguration>(); await ContextSeed.SeedDataBaseAsync(context, userManager, roleManager, fileService, configuration); } catch (Exception ex) { Console.WriteLine($"Exception while running Manage Data => {ex}"); } }
//public static void Main(string[] args) //{ // CreateHostBuilder(args).Build().Run(); //} //public static IHostBuilder CreateHostBuilder(string[] args) => // Host.CreateDefaultBuilder(args) // .ConfigureWebHostDefaults(webBuilder => // { // webBuilder.UseStartup<Startup>(); // }); 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 ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.SeedSuperAdminAsync(userManager, roleManager); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "Une erreur s'est produite lors de l'amorçage de la base de données."); } } 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>(); var userManager = services.GetRequiredService <UserManager <IdentityUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.SeedSuperAdminAsync(userManager); await ContextSeed.SeedIdentityUsersAsync(userManager); await ContextSeed.SeedKanbanTasksAsync(new KanbanTaskManager(context), userManager); //} //catch (Exception ex) //{ // var logger = loggerFactory.CreateLogger<Program>(); // logger.LogError(ex, "An error occurred seeding the DB."); //} } host.Run(); }
public static async Task ManageDataAsync(IHost host) { try { // This technique is used to obtain references to services using IServiceScope svcScope = host.Services.CreateScope( ); IServiceProvider svcProvider = svcScope.ServiceProvider; // Seed Data IServiceProvider services = svcScope.ServiceProvider; ApplicationDbContext context = services.GetRequiredService <ApplicationDbContext>( ); UserManager <HeimdallUser> userManager = services.GetRequiredService <UserManager <HeimdallUser> >( ); RoleManager <IdentityRole> roleManager = services.GetRequiredService <RoleManager <IdentityRole> >( ); await ContextSeed.RunSeedMethodsAsync(context, roleManager, userManager).ConfigureAwait(false); // The service will run your migrations ApplicationDbContext dbContextSvc = svcProvider.GetRequiredService <ApplicationDbContext>( ); await dbContextSvc.Database.MigrateAsync( ).ConfigureAwait(false); } catch (Exception ex) { Console.WriteLine($"Exception while running Manage Data -> {ex}"); } }
//public static void Main(string[] args) //{ // CreateHostBuilder(args).Build().Run(); //} public static async Task Main(string[] args) { var host = CreateHostBuilder(args).Build(); using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; var UserContext = services.GetRequiredService <ApplicationDbContext>(); HotelContext hotelContext = scope.ServiceProvider.GetService <HotelContext>(); ISeederService seederService = scope.ServiceProvider.GetService <ISeederService>(); //If database doesent exist, run the seeder from movieservice bool DatabaseDoesNotExist = hotelContext.Database.EnsureCreated(); if (DatabaseDoesNotExist) { seederService.SeedDataBase(); } ; if (!UserContext.Database.EnsureCreated()) { UserContext.Database.Migrate(); var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); await ContextSeed.SeedRolesAsync(userManager, roleManager); await ContextSeed.SeedAdminAsync(userManager, roleManager); } } 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 <LibraryContext>(); await context.Database.MigrateAsync(); await ContextSeed.SeedAsync(context, loggerFactory); var userManager = services.GetRequiredService <UserManager <AppUser> >(); var identityContext = services.GetRequiredService <LibraryIdentityDbContext>(); await identityContext.Database.MigrateAsync(); await LibraryIdentityDbContextSeed.SeedUserData(userManager); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occured during migration"); } } host.Run(); }
public async void MetaDataTest2() { using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); } using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { Item item = await context.Items.AsTracking() .Include(i => i.Brand) .Include(i => i.ItemCategories) .ThenInclude(t => t.Category) .Include(i => i.Variants) .ThenInclude(v => v.Vendor) .Include(i => i.Variants) .ThenInclude(v => v.Unit) .Where(i => i.Name == "5-MTHF") .FirstOrDefaultAsync(); Assert.Empty(item.MetaData); item.MetaData.Add("Test1", "1"); item.MetaData.Add("Test2", "2"); item.MetaData.Add("Test3", "3"); Assert.Equal(EntityState.Modified, context.Entry(item).State); int changes = await context.SaveChangesAsync(); Assert.Equal(1, changes); Assert.Equal(EntityState.Unchanged, context.Entry(item).State); } using (Context context2 = Context.ContextDesignFactory.CreateDbContext(Config)) { Item item2 = await context2.Items .Include(i => i.Brand) .Include(i => i.ItemCategories) .ThenInclude(t => t.Category) .Include(i => i.Variants) .ThenInclude(v => v.Vendor) .Include(i => i.Variants) .ThenInclude(v => v.Unit) .Where(i => i.Name == "5-MTHF") .FirstOrDefaultAsync(); Assert.Equal("1", item2.MetaData["Test1"]); Assert.Equal("2", item2.MetaData["Test2"]); Assert.Equal("3", item2.MetaData["Test3"]); await context2.Database.EnsureDeletedAsync(); } }
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 <Context>(options => { options.UseInMemoryDatabase("ecomm"); 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 <Context>(); 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. ContextSeed.SeedAsync(db, loggerFactory).Wait(); } catch (Exception ex) { logger.LogError(ex, $"An error occurred seeding the " + "database with test messages. Error: {ex.Message}"); } } }); }
public DatabaseFixture() { ServiceCollection serviceCollection = new ServiceCollection(); ConfigureServices(serviceCollection); this.serviceProvider = serviceCollection.BuildServiceProvider(); Config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", false) .Build(); Context = this.serviceProvider.GetService <Context>(); // Context.ContextDesignFactory.CreateDbContext(Config); ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); seed.SeedAsync(Context, logger, false, Environment.CurrentDirectory, "").Wait(); }
/// <summary> /// add mock data sql memory /// </summary> /// <param name="host"></param> private static void SeedDatabase(IHost host) { using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; var loggerFactory = services.GetRequiredService <ILoggerFactory>(); try { var aspnetRunContext = services.GetRequiredService <Context>(); ContextSeed.SeedAsync(aspnetRunContext, loggerFactory).Wait(); } catch (Exception exception) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(exception, "An error occurred seeding the DB."); } } }
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 logger = loggerFactory.CreateLogger <Program>(); // Beging logging logger?.LogInformation("Begin seeding roles into the database"); var context = services.GetRequiredService <ApplicationDbContext>(); var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var config = services.GetRequiredService <IConfiguration>(); // Seed the Roles into the database await ContextSeed.SeedRoleAsync(roleManager); //used User Secret.json to get the password var pwd = config["SuperAdmin"]; // Seed the SuperAdmin Role to the database await ContextSeed.SeedSuperAdminAsync(userManager, pwd); logger?.LogInformation("Seeding roles into the database was successful"); } catch (Exception ex) { // Log any issuse while seeding occurs var logger = loggerFactory.CreateLogger <Program>(); logger?.LogError(ex.Message, "An error occurred while seeding the DB. Seeding failed!!"); } } host.Run(); }
public async void NoTrackingTest2() { Item item = null; int count = 0; using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { ILogger <ContextSeed> logger = new Microsoft.Extensions.Logging.Abstractions.NullLogger <ContextSeed>(); ContextSeed seed = new ContextSeed(); await seed.SeedAsync(context, logger, false, Environment.CurrentDirectory, ""); item = await context.Items.Where(i => i.Name == "5-MTHF").FirstOrDefaultAsync(); item.Name += " - updated2"; // context.Update<Item>(item); int changes = await context.SaveChangesAsync(); Assert.Equal(0, changes); count = context.Items.Count(); } using (Context context = Context.ContextDesignFactory.CreateDbContext(Config)) { // item.Name += " - updated2"; context.Update <Item>(item); // context.Entry(item).State = EntityState.Modified; // Assert.Throws<InvalidOperationException>(() => context.Items.Update(item)); int changes = await context.SaveChangesAsync(); Assert.Equal(1, changes); } using (Context context2 = Context.ContextDesignFactory.CreateDbContext(Config)) { Item item2 = await context2.Items.Where(i => i.Name == "5-MTHF - updated2").FirstOrDefaultAsync(); Assert.NotNull(item2); Assert.Equal(count, context2.Items.Count()); await context2.Database.EnsureDeletedAsync(); } }
private static void seedAdmin(IHost host) { using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; var loggerFactory = services.GetRequiredService <ILoggerFactory>(); try { var context = services.GetRequiredService <DBContext>(); var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); ContextSeed.SeedRolesAsync(userManager, roleManager).Wait(); ContextSeed.SeedSuperAdminAsync(userManager, roleManager).Wait(); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occurred seeding the DB."); } } }
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>(); await ContextSeed.SeedLabels(context); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occurred seeding the DB with Labels."); } } host.Run(); }
public async static Task SeedDataAsync(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 <FpUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var configuration = services.GetRequiredService <IConfiguration>(); var fileService = services.GetRequiredService <IFP_FileService>(); await ContextSeed.RunSeedMethodsAsync(roleManager, userManager, context, configuration, fileService); } catch (Exception ex) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(ex, "An error occured seeding the DB"); } } }
public static async Task ManageData(IHost host) { try { using var svcScope = host.Services.CreateScope(); var svcProvider = svcScope.ServiceProvider; var dbContextSvc = svcProvider.GetRequiredService <ApplicationDbContext>(); await dbContextSvc.Database.MigrateAsync(); var services = svcScope.ServiceProvider; var context = services.GetRequiredService <ApplicationDbContext>(); var userManager = services.GetRequiredService <UserManager <FAUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var fileService = services.GetRequiredService <IAvatarService>(); await ContextSeed.SeedDataBaseAsync(context, userManager, roleManager, fileService); } catch (Exception ex) { Console.WriteLine($"Exception while running Manage Data => {ex}"); } }
public static void Main(string[] args) { var host = CreateHostBuilder(args).Build(); //Dependancy Injection to bring in all middleware services using in the app using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; var loggerFactory = services.GetRequiredService <ILoggerFactory>(); //Everything here surrounded in try catch incase something breaks try { //context for the database var context = services.GetRequiredService <ApplicationDbContext>(); //userMgr handles all the identityusers var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); //roleMgr handles all the identityroles var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); //check to make sure database is created, apply the latest migrations just in case. context.Database.EnsureCreated(); //if no roles exist in db seed roles if (!context.Roles.Any()) { ContextSeed.SeedRolesAsync(userManager, roleManager).GetAwaiter().GetResult(); } //if no users exist in db seed users and assign them to default roles if (!context.Users.Any()) { ContextSeed.SeedSuperAdminAsync(userManager, roleManager).GetAwaiter().GetResult(); } } catch (Exception e) { var logger = loggerFactory.CreateLogger <Program>(); logger.LogError(e, "Error occurred seeding the db. Check program.cs"); } } 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>(); DbInitializer.Initialize(context); var userManager = services.GetRequiredService <UserManager <ApplicationUser> >(); var roleManager = services.GetRequiredService <RoleManager <ApplicationRole> >(); var result = Task.Run(async() => await ContextSeed.SeedAsync(userManager, roleManager)); } catch (Exception ex) { var logger = services.GetRequiredService <ILogger <Program> >(); logger.LogError(ex, "An error occurred creating the DB."); } host.Run(); }
public static async Task ManageData(IHost host) { try { using var svcScope = host.Services.CreateScope(); var svcProvider = svcScope.ServiceProvider; var services = svcScope.ServiceProvider; var context = services.GetRequiredService <ApplicationDbContext>(); var userManager = services.GetRequiredService <UserManager <FpUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var configuration = services.GetRequiredService <IConfiguration>(); var fileService = services.GetRequiredService <IFP_FileService>(); await context.Database.MigrateAsync(); await ContextSeed.RunSeedMethodsAsync(roleManager, userManager, context, configuration, fileService); } catch (Exception ex) { Console.WriteLine($"Exception while running Manage Data => {ex}"); } }