public static void AddMongoDB <TMongoSeeder>(this IServiceCollection services, IConfiguration configuration) where TMongoSeeder : class, IDatabaseSeeder { IConfigurationSection mongoConfigurationSection = configuration.GetSection("mongo"); services.Configure <MongoOptions>(mongoConfigurationSection); services.AddSingleton(serviceProvider => { IOptions <MongoOptions> options = serviceProvider.GetService <IOptions <MongoOptions> >(); return(new MongoClient(options.Value.ConnectionString)); }); services.AddScoped(serviceProvider => { IOptions <MongoOptions> options = serviceProvider.GetService <IOptions <MongoOptions> >(); MongoClient client = serviceProvider.GetService <MongoClient>(); return(client.GetDatabase(options.Value.Database)); }); services.AddScoped <IDatabaseSeeder, TMongoSeeder>(); services.AddScoped <IDatabaseInitializer>(serviceProvider => { IOptions <MongoOptions> options = serviceProvider.GetService <IOptions <MongoOptions> >(); IMongoDatabase database = serviceProvider.GetService <IMongoDatabase>(); IDatabaseSeeder seeder = serviceProvider.GetService <IDatabaseSeeder>(); return(new MongoInitializer(database, seeder, options)); }); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IIdentitySeeder identitySeeder, IDatabaseSeeder databaseSeeder) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } 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(); app.UseEndpoints(endpoints => { endpoints.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); endpoints.MapRazorPages(); }); identitySeeder.Seed(); //Identity seeder needs to be run first so roles and admin are seeded databaseSeeder.Seed(); }
public void Configure( IApplicationBuilder applicationBuilder, IHostingEnvironment hostingEnvironment, IDatabaseInitializer databaseInitializer, IDatabaseSeeder databaseSeeder) { if (hostingEnvironment.IsDevelopment()) { applicationBuilder.UseDeveloperExceptionPage(); } applicationBuilder.UseStaticFiles(); applicationBuilder.UseHttpsRedirection(); applicationBuilder.UseCors(AllowAnyOriginPolicyName); applicationBuilder.UseMvc(routes => { routes.MapRoute("default", "api/{controller}/{action}/{id?}"); }); databaseInitializer.Initialize(); databaseSeeder.Seed(); }
/// <summary> /// Construct an <see cref="InstanceManager"/> /// </summary> /// <param name="instanceFactory">The value of <see cref="instanceFactory"/></param> /// <param name="ioManager">The value of <paramref name="ioManager"/></param> /// <param name="databaseContextFactory">The value of <paramref name="databaseContextFactory"/></param> /// <param name="assemblyInformationProvider">The value of <see cref="assemblyInformationProvider"/></param> /// <param name="jobManager">The value of <see cref="jobManager"/></param> /// <param name="serverControl">The value of <see cref="serverControl"/></param> /// <param name="systemIdentityFactory">The value of <see cref="systemIdentityFactory"/>.</param> /// <param name="asyncDelayer">The value of <see cref="asyncDelayer"/>.</param> /// <param name="databaseSeeder">The value of <see cref="databaseSeeder"/>.</param> /// <param name="serverPortProvider">The value of <see cref="serverPortProvider"/>.</param> /// <param name="generalConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="generalConfiguration"/>.</param> /// <param name="logger">The value of <see cref="logger"/></param> public InstanceManager( IInstanceFactory instanceFactory, IIOManager ioManager, IDatabaseContextFactory databaseContextFactory, IAssemblyInformationProvider assemblyInformationProvider, IJobManager jobManager, IServerControl serverControl, ISystemIdentityFactory systemIdentityFactory, IAsyncDelayer asyncDelayer, IDatabaseSeeder databaseSeeder, IServerPortProvider serverPortProvider, IOptions <GeneralConfiguration> generalConfigurationOptions, ILogger <InstanceManager> logger) { this.instanceFactory = instanceFactory ?? throw new ArgumentNullException(nameof(instanceFactory)); this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager)); this.databaseContextFactory = databaseContextFactory ?? throw new ArgumentNullException(nameof(databaseContextFactory)); this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider)); this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager)); this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl)); this.systemIdentityFactory = systemIdentityFactory ?? throw new ArgumentNullException(nameof(systemIdentityFactory)); this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer)); this.databaseSeeder = databaseSeeder ?? throw new ArgumentNullException(nameof(databaseSeeder)); this.serverPortProvider = serverPortProvider ?? throw new ArgumentNullException(nameof(serverPortProvider)); generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); lazyRestartRegistration = new Lazy <IRestartRegistration>(() => serverControl.RegisterForRestart(this)); instances = new Dictionary <long, InstanceContainer>(); bridgeHandlers = new Dictionary <string, IBridgeHandler>(); readyTcs = new TaskCompletionSource <object>(); instanceStateChangeSemaphore = new SemaphoreSlim(1); }
public MongoInitializer(IMongoDatabase database, IDatabaseSeeder seeder, IOptions <MongoOptions> options) { _database = database; _seeder = seeder; _seed = options.Value.Seed; }
/// <summary> /// Construct a <see cref="SqlServerDatabaseContext"/> /// </summary> /// <param name="dbContextOptions">The <see cref="DbContextOptions{TContext}"/> for the <see cref="DatabaseContext"/></param> /// <param name="databaseConfiguration">The <see cref="IOptions{TOptions}"/> of <see cref="DatabaseConfiguration"/> for the <see cref="DatabaseContext"/></param> /// <param name="databaseSeeder">The <see cref="IDatabaseSeeder"/> for the <see cref="DatabaseContext"/></param> /// <param name="logger">The <see cref="ILogger"/> for the <see cref="DatabaseContext"/></param> public PostgresSqlDatabaseContext( DbContextOptions <PostgresSqlDatabaseContext> dbContextOptions, IOptions <DatabaseConfiguration> databaseConfiguration, IDatabaseSeeder databaseSeeder, ILogger <PostgresSqlDatabaseContext> logger) : base(dbContextOptions, databaseConfiguration, databaseSeeder, logger) { }
//Ioption helps us to know if we should seed the database or not public DatabaseInitialiser(IMongoDatabase database, IDatabaseSeeder seeder, IOptions <MongoOption> options) { this._database = database; this.seed = options.Value.Seed; this._seeder = seeder; }
public MongoInitializer( IOptions <MongoOptions> options, IDatabaseSeeder databaseSeeder, IMongoDatabase database) { _seed = options.Value.Seed; _databaseSeeder = databaseSeeder; _database = database; }
public void InitializeDatabase(IDatabaseSeeder databaseSeeder, bool seed) { Database.EnsureCreated(); // Migrate() to use migration CreateTypes(); CreateStoredProcedures(); if (seed) { databaseSeeder.Seed(this); } }
protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.UseEnvironment("Test"); 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 <DeployManagerContext>(options => { options.UseInMemoryDatabase(options.GetType().Name); options.UseInternalServiceProvider(serviceProvider); }); // Build the service provider. Service = services.BuildServiceProvider(); // Create a scope to obtain a reference to the database contexts using (var scope = Service.CreateScope()) { var scopedServices = scope.ServiceProvider; var db = scopedServices.GetRequiredService <DeployManagerContext>(); var logger = scopedServices.GetRequiredService <ILogger <DeployManagerWebApiFactory <TStartup> > >(); // Ensure the database is created. db.Database.EnsureCreated(); try { // Seed the database with some specific test data. var seeders = new IDatabaseSeeder[] { new DeployTypeSeeder(), new ServerTypeSeeder(), new ServerInstanceSeeder(), }; foreach (var seeder in seeders) { seeder.SeedAsync(db).Wait(); } } catch (Exception ex) { logger.LogError(ex, "An error occurred seeding the " + "database. Error: {ex.Message}"); } } }); }
// ctor public MainViewModel( IDataImporterClass dataImporter, IDatabaseChecker databaseChecker, IDatabaseSeeder databaseSeeder, IDataLoader dataLoader) { _dataImporter = dataImporter; _databaseChecker = databaseChecker; _databaseSeeder = databaseSeeder; _dataLoader = dataLoader; ImportCommand = new RelayCommand(Import); LoadedCommand = new RelayCommand(Loaded); Games = new ObservableCollection<Game>(); }
// public async Task InitializeAsync() // { // if(this._initialized){ // return; // } // RegisterConventions(); // this._initialized=true; // if(!this._seed){ // return; // } // await this.seeder.SeedAsync(); // } public async Task InitializeAsync(IDatabaseSeeder seeder) { if (this._initialized) { return; } RegisterConventions(); this._initialized = true; if (!this._seed) { return; } await seeder.SeedAsync(); }
private static IServiceCollection AddAspNetIdentitySeedServices(this IServiceCollection services, IHostingEnvironment environment) { services.AddScoped <ISeedDataProvider <UserDbContext> >(opts => new SeedDataProvider <UserDbContext>( opts.GetService <ILogger <SeedDataProvider <UserDbContext> > >(), "NLIP.iShare.AuthorizationRegistry.IdentityServer.Migrations.Seed.AspNetIdentity", typeof(IdentityServerConfiguration).GetTypeInfo().Assembly) ); services.AddScoped <Migrations.Seed.AspNetIdentity.Seeders.ProdDatabaseSeeder>(); services.AddScoped <Migrations.Seed.AspNetIdentity.Seeders.QaDatabaseSeeder>(); services.AddScoped <Migrations.Seed.AspNetIdentity.Seeders.DevelopmentDatabaseSeeder>(); services.AddScoped <Migrations.Seed.AspNetIdentity.Seeders.AccDatabaseSeeder>(); services.AddScoped(opts => { var environmentName = environment.EnvironmentName; IDatabaseSeeder <UserDbContext> databaseSeeder = null; switch (environmentName) { case Environments.Qa: databaseSeeder = opts.GetService <Migrations.Seed.AspNetIdentity.Seeders.QaDatabaseSeeder>(); break; case Environments.Prod: databaseSeeder = opts.GetService <Migrations.Seed.AspNetIdentity.Seeders.ProdDatabaseSeeder>(); break; case Environments.Acc: databaseSeeder = opts.GetService <Migrations.Seed.AspNetIdentity.Seeders.AccDatabaseSeeder>(); break; case Environments.Development: databaseSeeder = opts.GetService <Migrations.Seed.AspNetIdentity.Seeders.DevelopmentDatabaseSeeder>(); break; default: throw new DatabaseSeedException($"{environmentName} is not registered."); } return(databaseSeeder); }); return(services); }
public void Configure( IApplicationBuilder applicationBuilder, IDatabaseInitializer databaseInitializer, IDatabaseSeeder databaseSeeder) { applicationBuilder.UseDeveloperExceptionPage(); applicationBuilder.UseStaticFiles(); databaseInitializer.Initialize(); applicationBuilder.UseCors(AllowAnyOriginPolicyName); applicationBuilder.UseMvc(routes => { routes.MapRoute("default", "api/{controller}/{action}/{id?}"); }); applicationBuilder.UseAuthentication(); databaseSeeder.Seed(); }
/// <summary> /// Construct a <see cref="DatabaseContext"/> /// </summary> /// <param name="dbContextOptions">The <see cref="DbContextOptions"/> for the <see cref="DatabaseContext"/>.</param> /// <param name="databaseConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="DatabaseConfiguration"/></param> /// <param name="databaseSeeder">The value of <see cref="databaseSeeder"/></param> /// <param name="logger">The value of <see cref="Logger"/></param> public DatabaseContext(DbContextOptions dbContextOptions, IOptions <DatabaseConfiguration> databaseConfigurationOptions, IDatabaseSeeder databaseSeeder, ILogger logger) : base(dbContextOptions) { DatabaseConfiguration = databaseConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(databaseConfigurationOptions)); this.databaseSeeder = databaseSeeder ?? throw new ArgumentNullException(nameof(databaseSeeder)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); usersCollection = new DatabaseCollection <User>(Users); instancesCollection = new DatabaseCollection <Instance>(Instances); instanceUsersCollection = new DatabaseCollection <InstanceUser>(InstanceUsers); compileJobsCollection = new DatabaseCollection <CompileJob>(CompileJobs); repositorySettingsCollection = new DatabaseCollection <RepositorySettings>(RepositorySettings); dreamMakerSettingsCollection = new DatabaseCollection <DreamMakerSettings>(DreamMakerSettings); dreamDaemonSettingsCollection = new DatabaseCollection <DreamDaemonSettings>(DreamDaemonSettings); chatBotsCollection = new DatabaseCollection <ChatBot>(ChatBots); chatChannelsCollection = new DatabaseCollection <ChatChannel>(ChatChannels); revisionInformationsCollection = new DatabaseCollection <RevisionInformation>(RevisionInformations); jobsCollection = new DatabaseCollection <Job>(Jobs); reattachInformationsCollection = new DatabaseCollection <ReattachInformation>(ReattachInformations); watchdogReattachInformationsCollection = new DatabaseCollection <DualReattachInformation>(WatchdogReattachInformations); }
public InstallController( UserManager <ApplicationUser> userManager, RoleManager <ApplicationRole> roleManager, ICompanyWorkData companyWorkData, ISchedulerWorkData schedulerWorkData, IAccountingWorkData accountingWorkData, IMapper mapper, ILoggerFactory loggerFactory, IDatabaseSeeder dataSeeder, IRolesSeder rolesSeeder, IServiceScopeFactory services, IEventsFactory eventsFactory) : base(companyWorkData, schedulerWorkData, accountingWorkData, mapper) { this.userManager = userManager; this.roleManager = roleManager; this.dataSeeder = dataSeeder; this.rolesSeeder = rolesSeeder; this.services = services; this.eventsFactory = eventsFactory; this.logger = loggerFactory.CreateLogger <InstallController>(); }
public MongoInitializer(IDatabaseSeeder databaseSeeder, IOptions <MongoOptions> options) { this.databaseSeeder = databaseSeeder; this.seed = options.Value.Seed; }
/// <summary> /// Construct a <see cref="SqlServerDatabaseContext"/> /// </summary> /// <param name="dbContextOptions">The <see cref="DbContextOptions{TContext}"/> for the <see cref="DatabaseContext"/></param> /// <param name="databaseConfiguration">The <see cref="IOptions{TOptions}"/> of <see cref="DatabaseConfiguration"/> for the <see cref="DatabaseContext"/></param> /// <param name="databaseSeeder">The <see cref="IDatabaseSeeder"/> for the <see cref="DatabaseContext"/></param> /// <param name="logger">The <see cref="ILogger"/> for the <see cref="DatabaseContext"/></param> public SqlServerDatabaseContext(DbContextOptions <SqlServerDatabaseContext> dbContextOptions, IOptions <DatabaseConfiguration> databaseConfiguration, IDatabaseSeeder databaseSeeder, ILogger <SqlServerDatabaseContext> logger) : base(dbContextOptions, databaseConfiguration, databaseSeeder, logger) { }
/// <summary> /// Initializes a new instance of the <see cref="MongoInitializer"/> class. /// </summary> /// <param name="options">Options for initilzation</param> /// <param name="seeder">the database seeder</param> public MongoInitializer(IOptions <MongoOptions> options, IDatabaseSeeder seeder) { this._seeder = seeder; this._seed = options.Value.Seed; }
/// <summary>MySqlInitializer /// Constructor /// </summary> /// <param name="database">Database connection</param> /// <param name="seeder">Database seeder</param> /// <param name="options">MySqlOptions object</param> public MySqlInitializer(MySqlConnection database, IDatabaseSeeder seeder, IOptions <MySqlOptions> options) { Connection = database; _seeder = seeder; _seed = options.Value.Seed; }
/// <summary> /// Construct a <see cref="DatabaseContext{TParentContext}"/> /// </summary> /// <param name="dbContextOptions">The <see cref="DbContextOptions{TParentContext}"/> for the <see cref="DatabaseContext{TParentContext}"/></param> /// <param name="databaseConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing the value of <see cref="DatabaseConfiguration"/></param> /// <param name="databaseSeeder">The value of <see cref="databaseSeeder"/></param> /// <param name="logger">The value of <see cref="Logger"/></param> public DatabaseContext(DbContextOptions <TParentContext> dbContextOptions, IOptions <DatabaseConfiguration> databaseConfigurationOptions, IDatabaseSeeder databaseSeeder, ILogger logger) : base(dbContextOptions) { DatabaseConfiguration = databaseConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(databaseConfigurationOptions)); this.databaseSeeder = databaseSeeder ?? throw new ArgumentNullException(nameof(databaseSeeder)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public MongoInitializer(IOptions <MongoOptions> options, IMongoDatabase database, IDatabaseSeeder databaseSeeder) { this.database = database; seed = options.Value.Seed; this.databaseSeeder = databaseSeeder; }
public MongoIntializer(IMongoDatabase mongoDatabase, IOptions <MongoOptions> options, IDatabaseSeeder seeder) { _seeder = seeder; _mongoDatabase = mongoDatabase; _seed = options.Value.Seed; }
private void SeedDatabase(IDatabaseSeeder databaseSeeder) { databaseSeeder.Seed(); }
public MongoDatabaseInitializer(IDatabaseSeeder seeder, IOptions <MongoOptions> options) { _seeder = seeder; _seed = options.Value.Seed; }
public SeedDatabaseCommandHandler(IUnitOfWork unitOfWork, IDatabaseSeeder databaseSeeder) { _unitOfWork = unitOfWork; _databaseSeeder = databaseSeeder; }
public DatabaseInitializer(IMongoDatabase db, IDatabaseSeeder seeder, IOptions <MongoOptions> opts) { _database = db; _seeder = seeder; _seed = opts.Value.Seed; }