public void Main(string[] args) { Log("started with args: "+String.Join(" ", args)); var configBuilder = new ConfigurationBuilder(); configBuilder.AddJsonFile("appsettings.json"); Configuration = configBuilder.Build(); if (args.Contains("--windows-service")) { try { Log("WWWService Main()"); Run(this); return; } catch(Exception x) { Log("WWWService Main() Exception: "+ x.Message); } } OnStart(null); Console.ReadLine(); OnStop(); }
public static IServiceCollection BuildConfiguration(this IServiceCollection services, IConfigurationRoot configuration) { AssemblyApi.AssemblyManager.Initialize(configuration); services.Configure<ServerOptions>(configuration.GetSection("ServerOptions")); return services; }
public AccountController(IConfigurationRoot appSettings, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, ILoggerFactory loggerFactory) { _appSettings = appSettings; _userManager = userManager; _signInManager = signInManager; _logger = loggerFactory.CreateLogger<AccountController>(); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IConfigurationRoot configuration) { loggerFactory.AddConsole(configuration.GetSection("Logging")); loggerFactory.AddDebug(); // For more details on creating database during deployment see http://go.microsoft.com/fwlink/?LinkID=615859 try { using (var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>() .CreateScope()) { using (var db = serviceScope.ServiceProvider.GetService<ApplicationDbContext>()) { db.Database.EnsureCreated(); db.Database.Migrate(); } } } catch (Exception exception) { } app.UseCors("AllowAllOrigins"); // TODO: allow collection of allowed origins per client app.UseIISPlatformHandler(); app.UseStaticFiles(); app.UseMvc(); }
public HomeController(IConfigurationRoot configuration, IOptions<OtherSettings> otherSettings, ILogger<HomeController> logger, IMemoryCache memoryCache) { _configuration = configuration; _otherSettings = otherSettings.Value; _logger = logger; _memoryCache = memoryCache; }
public void ConfigureServices(IServiceCollection services, IConfigurationRoot configuration) { services.AddEntityFramework() .AddSqlServer() .AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(configuration["Data:DefaultConnection:ConnectionString"])); services.AddIdentity<ApplicationUser, IdentityRole>() .AddEntityFrameworkStores<ApplicationDbContext>() .AddDefaultTokenProviders(); // Add framework services. services.AddMvc().AddJsonOptions(options => { options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); }); // Add CORS support services.AddCors(options => { options.AddPolicy("AllowAllOrigins", builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod()); }); services.AddScoped<IUsersRepository, AspNetIdentityUsersRepository>(); services.AddScoped<IUserClaimsRepository, AspNetIdentityUserClaimsRepository>(); }
public static void Main(string[] args) { var configBuilder = new ConfigurationBuilder().AddCommandLine(args); Configuration = configBuilder.Build(); string configFile = Configuration["config"]; if (configFile != null) { configBuilder.AddJsonFile(configFile, optional: false); Configuration = configBuilder.Build(); } ConfigurationBinder.Bind(Configuration.GetSection("startup"), _startupOptions); ConfigurationBinder.Bind(Configuration.GetSection("security"), _securityOptions); _loggerFactory .AddDebug() .AddConsole(LogLevel.Trace) .AddProvider(new FileLoggerProvider(_startupOptions.Name)); _logger = _loggerFactory.CreateLogger<Program>(); if (_startupOptions.Name != null) { _logger.LogInformation(Resources.Info_BrokerName, _startupOptions.Name); } var tlsConfig = new TlsConfiguration(_logger, _securityOptions); var httpsOptions = tlsConfig.GetHttpsOptions(Configuration); Uri uri = GetServerUri(Configuration); try { CreateWebHost(httpsOptions).Run(); } catch(AggregateException ex) when (ex.IsPortInUseException()) { _logger.LogError(0, ex.InnerException, Resources.Error_ConfiguredPortNotAvailable, uri?.Port); } }
public void Run() { try { Console.WriteLine("Reading Configuration"); var builder = new ConfigurationBuilder() .SetBasePath(PlatformServices.Default.Application.ApplicationBasePath) .AddJsonFile("config.json") .AddEnvironmentVariables(); _config = builder.Build(); _ctx = new OldWilderContext(_config); _newCtx = new WilderContext(_config); _repo = new WilderRepository(_config, _newCtx); Console.WriteLine("Migrating Stories"); MigrateStories(); //TODO More migration } catch (Exception ex) { Console.WriteLine(ex.ToString()); Console.ReadKey(); } }
public static IServiceCollection AddCloudFoundry(this IServiceCollection serviceCollection, IConfigurationRoot configuration) { string vcapRaw = configuration.GetSection("VCAP_SERVICES").Value; Dictionary<String, BoundService> results = new Dictionary<string, BoundService>(); VcapParser parser = new VcapParser(); if (!string.IsNullOrEmpty(vcapRaw)) { try { results = parser.ParseConfigurationForVcap(vcapRaw); } catch (Exception ex) { throw new ArgumentException("VCAP_SERVICES", "Could not parse VCAP_SERVICES environment variable or other substitute configuration. Cannot enable cloud foundry configuration.", ex); } } serviceCollection.Configure<CloudFoundryBoundServiceOptions>(options => { options.BoundServices = results; }); return serviceCollection; }
public static ILoggerFactory AddNLog(this ILoggerFactory factory, IConfigurationRoot configuration) { LogManager.AddHiddenAssembly(typeof (AspNetExtensions).GetTypeInfo().Assembly); factory.AddProvider(new NLogLoggerProvider()); LogManager.Configuration = new XmlLoggingConfiguration(configuration[NLogConfigurationPathKey], true); return factory; }
public Startup(IApplicationEnvironment appEnv) { _configurationRoot = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddJsonFile("config.json") .Build(); }
/// <summary> /// インスタンスを生成します。 /// </summary> /// <param name="env"></param> public Startup(IHostingEnvironment env) { this.Configuration = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddEnvironmentVariables() .Build(); }
public Startup() { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json"); builder.AddEnvironmentVariables(); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { var builder = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddJsonFile("config.json"); Configuration = builder.Build(); }
public AzureEndpoints(IConfigurationRoot configuration) { DocumentDBUrl = configuration["APPSETTING_ddburl"]; DocumentDBKey = configuration["APPSETTING_ddbkey"]; SearchAccount = configuration["APPSETTING_searchaccount"]; SearchKey = configuration["APPSETTING_searchkey"]; }
public UmbracoConfig(IApplicationEnvironment appEnv) { var cfg = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddJsonFile("umbraco.json"); _config = cfg.Build(); }
public ConfigController(IConfigurationRoot configuration, IApplicationEnvironment appEnv) { this.configuration = configuration; string applicationPath = appEnv.ApplicationBasePath; settings_file = Path.Combine(applicationPath, SETTINGS_FILE_NAME); project_file = Path.Combine(applicationPath, "project.json"); }
public static ILifetimeScope CreateAutofacContainer(this IServiceCollection services, IConfigurationRoot configuration) { var builder = new ContainerBuilder(); // Load web specific dependencies builder.RegisterType<AuthMessageSender>() .As<IEmailSender>().InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(typeof(Startup).GetTypeInfo().Assembly).AsImplementedInterfaces(); builder.RegisterAssemblyTypes(typeof (CartCommandService).GetTypeInfo().Assembly, typeof (ICartCommandService).GetTypeInfo().Assembly) .AsImplementedInterfaces(); var databaseInitializer = new MigrateToLatestVersion(new SampleDataSeeder()); builder.AddDataOnion(new DbContextConfig(configuration.GetConnectionString("DefaultConnection"), typeof(MusicStoreContext), databaseInitializer)); // Populate the container with services that were previously registered builder.Populate(services); builder.RegisterType<BaseRepository<Album, MusicStoreContext>>().As<IRepository<Album>>(); builder.RegisterType<BaseRepository<Artist, MusicStoreContext>>().As<IRepository<Artist>>(); builder.RegisterType<BaseRepository<Cart, MusicStoreContext>>().As<IRepository<Cart>>(); builder.RegisterType<BaseRepository<CartItem, MusicStoreContext>>().As<IRepository<CartItem>>(); builder.RegisterType<BaseRepository<Genre, MusicStoreContext>>().As<IRepository<Genre>>(); builder.RegisterType<BaseRepository<Order, MusicStoreContext>>().As<IRepository<Order>>(); builder.RegisterType<BaseRepository<OrderDetail, MusicStoreContext>>().As<IRepository<OrderDetail>>(); var container = builder.Build(); return container; }
public AuthAjaxActionFilter(IConfigurationRoot configurationRoot) { _configurationRoot = configurationRoot; Area = _configurationRoot["Filters:Configuration:AuthActionFilter:Area"]; Controller = _configurationRoot["Filters:Configuration:AuthActionFilter:Controller"]; Action = _configurationRoot["Filters:Configuration:AuthActionFilter:Action"]; }
public ConsulServiceDiscovery() { var builder = new ConfigurationBuilder() .AddJsonFile("consul.json"); Configuration = builder.Build(); }
public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment, IRuntimeEnvironment runtimeEnvironment) { log("Startup"); log("Platform = " + runtimeEnvironment.OperatingSystem); string PrjFolder = ""; // Set up configuration sources. var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddEnvironmentVariables(); Configuration = builder.Build(); try { PrjFolder = Directory.GetParent(hostingEnvironment.WebRootPath).FullName; } catch { // bei migrations klappts nicht mit der Ermittlung des Pfads aus env PrjFolder = Directory.GetCurrentDirectory(); log("Could't get project folder from HostingEnvironment, using CurDir: " + PrjFolder); } _DataFolder = Path.Combine(PrjFolder, "data"); log("DataFolder = " + _DataFolder); // Ordner überprüfen try { string AcessTestFileName = Path.Combine(_DataFolder, "_accestest.accestest"); File.Create(AcessTestFileName); } catch (Exception E) { log("Could't write in DataFolder: " + E.Message); } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { Configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .Build(); app.UseStaticFiles(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{tinyId?}"); }); }
/// <summary> /// /// </summary> /// <param name="spoAuthorization"></param> /// <param name="generalSettings"></param> /// <param name="searchSettings"></param> public Search(ISPOAuthorization spoAuthorization, IConfigurationRoot configuration, ICustomLogger customLogger, IUsersDetails userDetails, ISPList spList, IOptions<GeneralSettings> generalSettings, IOptions<SharedSettings> sharedSettings, IOptions<LogTables> logTables, IOptions<SearchSettings> searchSettings, IOptions<CamlQueries> camlQueries, IOptions<ListNames> listNames, IOptions<ErrorSettings> errorSettings) { this.spoAuthorization = spoAuthorization; this.generalSettings = generalSettings.Value; this.searchSettings = searchSettings.Value; this.userDetails = userDetails; this.customLogger = customLogger; this.logTables = logTables.Value; this.spList = spList; this.camlQueries = camlQueries.Value; this.listNames = listNames.Value; this.sharedSettings = sharedSettings.Value; this.errorSettings = errorSettings.Value; this.configuration = configuration; }
public Startup(IApplicationEnvironment appEnv) { var builder = new ConfigurationBuilder() .AddJsonFile("config.json"); Configuration = builder.Build(); }
public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true); Configuration = builder.Build(); }
public Startup(IApplicationEnvironment appEnv) { var confBuilder = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddJsonFile("appsettings.json") .AddEnvironmentVariables(); _configuration = confBuilder.Build(); }
public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment) { this.startupConfiguration = new ConfigurationBuilder() .SetBasePath(applicationEnvironment.ApplicationBasePath) .AddJsonFile("config.json") .Build(); }
public AuthMiddlewarePlugin(IConfigurationRoot configurationRoot) { _configurationRoot = configurationRoot; Area = _configurationRoot["Filters:Configuration:AuthActionFilter:Area"]; Controller = _configurationRoot["Filters:Configuration:AuthActionFilter:Controller"]; Action = _configurationRoot["Filters:Configuration:AuthActionFilter:Action"]; }
private static void FrontLoadFilterItems(IConfigurationRoot configurationRoot) { /* var filterItem = CreateFilterItem(settings.Value.Authorization.Filter); TypeToFilterItem.Add(settings.Value.Authorization.Filter, filterItem); if (settings.Value.SimpleMany != null) { if (settings.Value.SimpleMany.OptOut != null) { foreach (var record in settings.Value.SimpleMany.OptOut) { filterItem = CreateFilterItem(record.Filter); TypeToFilterItem.Add(record.Filter, filterItem); } } if (settings.Value.SimpleMany.OptIn != null) { foreach (var record in settings.Value.SimpleMany.OptIn) { filterItem = CreateFilterItem(record.Filter); TypeToFilterItem.Add(record.Filter, filterItem); } } } */ }
public FunContext(IConfigurationRoot config) { _config = config; Database.EnsureCreated(); Database.Migrate(); }
public KworkPracticeTaskWebCoreModule(IHostingEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
public PiggyvaultWebHostModule(IHostingEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
public static void Main(string[] args) { try { int workerThreads; int completionPortThreads; System.Threading.ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads); if (workerThreads < 16) { workerThreads = 16; System.Threading.ThreadPool.SetMinThreads(workerThreads, completionPortThreads); } IConfigurationBuilder builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .AddCommandLine(args); IConfigurationRoot configuration = builder.Build(); int port = 14050; IConfigurationSection section = configuration.GetSection("ChangeNotification"); if (section != null) { section = section.GetSection("NotificationTCPPort"); if (section != null) { if (!int.TryParse(section.Value, out port)) { port = 14050; } } } Version version = Assembly.GetExecutingAssembly().GetName().Version; Console.Write("ChangeNotification ("); Console.Write(version.ToString()); Console.WriteLine(")"); ServiceConfiguration.DisplayConfig(); ApplicationEventLog.LogLevel = System.Diagnostics.EventLogEntryType.Information; BusinessLogicFactory.NotificationOrchestrator.Start(); NotificationTcpServer server = new NotificationTcpServer(); server.StartListening(port); _ShutdownEvent = new ManualResetEvent(false); Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { _ShutdownEvent.Set(); e.Cancel = true; }; Console.WriteLine("Press Ctrl+C to stop the server."); _ShutdownEvent.WaitOne(); Console.WriteLine("Exiting."); server.StopListening(); BusinessLogicFactory.NotificationOrchestrator.Stop(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
// clients want to access resources (aka scopes) public static IEnumerable <Client> GetClients(IConfigurationRoot Configuration) { // client credentials client return(new List <Client> { new Client { ClientId = "client", AllowedGrantTypes = GrantTypes.ClientCredentials, ClientSecrets = { new Secret("secret".Sha256()) }, AllowedScopes = { "api1" } }, // resource owner password grant client new Client { ClientId = "ro.client", AllowedGrantTypes = GrantTypes.ResourceOwnerPassword, ClientSecrets = { new Secret("secret".Sha256()) }, AllowedScopes = { "api1", IdentityServerConstants.StandardScopes.OfflineAccess }, AllowOfflineAccess = true, AllowedCorsOrigins = { Configuration["IdentityServerConfig:ResourceOwnerJsClientUri"] } }, // OpenID Connect hybrid flow and client credentials client (MVC) new Client { ClientId = "mvc", ClientName = "MVC Client", AllowedGrantTypes = GrantTypes.CodeAndClientCredentials, RequireConsent = false, ClientSecrets = { new Secret("secret".Sha256()) }, //RedirectUris = { $"{Configuration["IdentityServerConfig:HybridMvcClientUri"]}/signin-oidc"}, RedirectUris = { "http://localhost/IdentityServer" }, PostLogoutRedirectUris = { "http://identityserverexample.azurewebsites.net" }, AllowedScopes = { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile, "api1" }, AllowOfflineAccess = true, AllowedCorsOrigins = { "http://identityserverexample.azurewebsites.net", "http://localhost" } }, // JavaScript Client new Client { ClientId = "js", ClientName = "JavaScript Client", AllowedGrantTypes = GrantTypes.Implicit, AllowAccessTokensViaBrowser = true, RequireConsent = false, RedirectUris = { $"{Configuration["IdentityServerConfig:ImplicitJsClientUri"]}/callback" }, PostLogoutRedirectUris = { $"{Configuration["IdentityServerConfig:ImplicitJsClientUri"]}" }, AllowedCorsOrigins = { Configuration["IdentityServerConfig:ImplicitJsClientUri"] }, AllowedScopes = { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile, "api1", "role" }, }, // React Client new Client { ClientId = "react", ClientName = "React Client", AllowedGrantTypes = GrantTypes.Implicit, AllowAccessTokensViaBrowser = true, RedirectUris = { $"{Configuration["IdentityServerConfig:ImplicitReactClientUri"]}/callback.html" }, PostLogoutRedirectUris = { Configuration["IdentityServerConfig:ImplicitReactClientUri"] }, AllowedCorsOrigins = { Configuration["IdentityServerConfig:ImplicitReactClientUri"] }, AllowedScopes = { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile, "api1" }, }, // React Native Client new Client { ClientId = "native.code", ClientName = "Native Client (Code with PKCE)", RedirectUris = { "https://notused" }, PostLogoutRedirectUris = { "https://notused" }, RequireClientSecret = false, AllowedGrantTypes = GrantTypes.Code, RequirePkce = true, AllowedScopes = { "openid", "profile", "email", "api1" }, AllowOfflineAccess = true } }); }
public Settings() { configuration = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .Build(); }
public AppConfigurationAccessor(IHostingEnvironment env) { Configuration = env.GetAppConfiguration(); }
// DiscordSocketClient, CommandService, and IConfigurationRoot are injected automatically from the IServiceProvider public StartupService(IServiceProvider provider, DiscordSocketClient discord, CommandService commands, IConfigurationRoot config) { this._provider = provider; this._config = config; this._discord = discord; this._commands = commands; }
public DefaultAppConfigurationAccessor() { Configuration = AppConfigurations.Get(Directory.GetCurrentDirectory()); }
public IntuitWebHostModule(IWebHostEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
public MovieDbContext(IConfigurationRoot config, DbContextOptions options) : base(options) { _config = config; }
/// <summary> /// Register DbContexts /// </summary> /// <typeparam name="TConfigurationDbContext"></typeparam> /// <typeparam name="TPersistedGrantDbContext"></typeparam> /// <typeparam name="TLogDbContext"></typeparam> /// <typeparam name="TIdentityDbContext"></typeparam> /// <param name="services"></param> /// <param name="hostingEnvironment"></param> /// <param name="configuration"></param> public static void AddDbContexts <TIdentityDbContext, TConfigurationDbContext, TPersistedGrantDbContext, TLogDbContext>(this IServiceCollection services, IHostingEnvironment hostingEnvironment, IConfigurationRoot configuration) where TIdentityDbContext : DbContext where TPersistedGrantDbContext : DbContext, IAdminPersistedGrantDbContext where TConfigurationDbContext : DbContext, IAdminConfigurationDbContext where TLogDbContext : DbContext, IAdminLogDbContext { if (hostingEnvironment.IsStaging()) { services.RegisterDbContextsStaging <TIdentityDbContext, TConfigurationDbContext, TPersistedGrantDbContext, TLogDbContext>(); } else { services.RegisterDbContexts <TIdentityDbContext, TConfigurationDbContext, TPersistedGrantDbContext, TLogDbContext>(configuration); } }
public ContactsWebHostModule(IHostingEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
/// <summary> /// Register DbContexts for IdentityServer ConfigurationStore and PersistedGrants, Identity and Logging /// Configure the connection strings in AppSettings.json /// </summary> /// <typeparam name="TConfigurationDbContext"></typeparam> /// <typeparam name="TPersistedGrantDbContext"></typeparam> /// <typeparam name="TLogDbContext"></typeparam> /// <param name="services"></param> /// <param name="configuration"></param> public static void RegisterDbContexts <TIdentityDbContext, TConfigurationDbContext, TPersistedGrantDbContext, TLogDbContext>(this IServiceCollection services, IConfigurationRoot configuration) where TIdentityDbContext : DbContext where TPersistedGrantDbContext : DbContext, IAdminPersistedGrantDbContext where TConfigurationDbContext : DbContext, IAdminConfigurationDbContext where TLogDbContext : DbContext, IAdminLogDbContext { var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name; // Config DB for identity services.AddDbContext <TIdentityDbContext>(options => options.UseSqlServer(configuration.GetConnectionString(ConfigurationConsts.IdentityDbConnectionStringKey), sql => sql.MigrationsAssembly(migrationsAssembly))); // Config DB from existing connection services.AddConfigurationDbContext <TConfigurationDbContext>(options => { options.ConfigureDbContext = b => b.UseSqlServer(configuration.GetConnectionString(ConfigurationConsts.ConfigurationDbConnectionStringKey), sql => sql.MigrationsAssembly(migrationsAssembly)); }); // Operational DB from existing connection services.AddOperationalDbContext <TPersistedGrantDbContext>(options => { options.ConfigureDbContext = b => b.UseSqlServer(configuration.GetConnectionString(ConfigurationConsts.PersistedGrantDbConnectionStringKey), sql => sql.MigrationsAssembly(migrationsAssembly)); }); // Log DB from existing connection services.AddDbContext <TLogDbContext>(options => options.UseSqlServer( configuration.GetConnectionString(ConfigurationConsts.AdminLogDbConnectionStringKey), optionsSql => optionsSql.MigrationsAssembly(migrationsAssembly))); }
public void Initialize(IConfigurationRoot config) { InitializeConfiguration(config); }
public SourceDbContext(DbContextOptions <SourceDbContext> options, IConfigurationRoot configuration) : base(options) { ConnectionString = configuration.GetConnectionString(SourceDbConsts.ConnectionStringName); dbType = Database.ProviderName.GetDBType(); }
/// <summary> /// Register shared DbContext /// </summary> /// <typeparam name="TContext"></typeparam> /// <param name="services"></param> /// <param name="hostingEnvironment"></param> /// <param name="configuration"></param> public static void AddDbContexts <TContext>(this IServiceCollection services, IHostingEnvironment hostingEnvironment, IConfigurationRoot configuration) where TContext : DbContext { if (hostingEnvironment.IsStaging()) { services.RegisterDbContextsStaging <TContext>(); } else { services.RegisterDbContexts <TContext>(configuration); } }
protected override void ConfigureJobServices(IServiceCollection services, IConfigurationRoot configurationRoot) { ConfigureInitializationSection <InitializationConfiguration>(services, configurationRoot); }
/// <summary> /// Register shared DbContext for IdentityServer ConfigurationStore and PersistedGrants, Identity and Logging /// Configure the connection string in AppSettings.json - use AdminConnection key /// </summary> /// <typeparam name="TContext"></typeparam> /// <param name="services"></param> /// <param name="configuration"></param> public static void RegisterDbContexts <TContext>(this IServiceCollection services, IConfigurationRoot configuration) where TContext : DbContext { var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name; var operationalStoreOptions = new OperationalStoreOptions(); services.AddSingleton(operationalStoreOptions); var storeOptions = new ConfigurationStoreOptions(); services.AddSingleton(storeOptions); services.AddDbContext <TContext>(options => options.UseSqlServer(configuration.GetConnectionString(ConfigurationConsts.AdminConnectionStringKey), optionsSql => optionsSql.MigrationsAssembly(migrationsAssembly))); }
public HelpCommands(IConfigurationRoot configuration) => _configuration = configuration;
public AcceptanceTest(ITestOutputHelper testOutputHelper) { _testOutputHelper = testOutputHelper ?? throw new ArgumentNullException(nameof(testOutputHelper)); _configuration = TestConfiguration.GetConfiguration(); _backendService = new BackendService(_configuration, _testOutputHelper); }
public EMSWebCoreModule(IHostingEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
protected override void ConfigureAutofacServices(ContainerBuilder containerBuilder, IConfigurationRoot configurationRoot) { }
public SCFBuilder(IServiceCollection services, IConfigurationRoot configuration) { Services = services ?? throw new ArgumentNullException(nameof(services)); Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); }
public static IIdentityServerBuilder AddLingIdentitySServer(this IIdentityServerBuilder builder, IConfigurationRoot config) { builder.Services.ConfigurePOCO(config.GetSection("IdentityOptions"), () => new IdentityOptions()); builder.Services.AddTransient <IUserRepository, UserInMemoryRepository>(); builder.Services.AddTransient <IResourceRepository, ResourceInMemoryRepository>(); builder.Services.AddTransient <IClientRepository, ClientInMemoryRepository>(); builder.Services.AddTransient <IClientStore, ClientInMemoryRepository>(); builder.Services.AddTransient <IResourceStore, ResourceInMemoryRepository>(); builder.Services.AddTransient <IPersistedGrantStore, PersistedGrantStore>(); //services builder.Services.AddTransient <IUserService, UserService>(); builder.Services.AddTransient <IPasswordService, PasswordService>(); //validators builder.Services.AddTransient <IResourceOwnerPasswordValidator, ResourceOwnerPasswordValidator>(); builder.AddProfileService <ProfileService>(); return(builder); }
public TransportClientModule(IConfigurationRoot jimuAppSettings) : base(jimuAppSettings) { _options = jimuAppSettings.GetSection(typeof(TransportOptions).Name).Get <TransportOptions>(); }
public App(IConfigurationRoot configuration, IEnigmaService enigmaService) { _config = configuration; _enigmaService = enigmaService; }
public void Install(IServiceCollection services, IConfigurationRoot configuration) { }
public ConfigHooks(TestContext context) { _configRoot = ConfigurationManager.BuildConfig("D76B6EB8-F1A2-4A51-9B8F-21E1B6B81E4F"); context.Config = new Config(); context.UserAccounts = new List <UserAccount>(); }
public NopcommerceWebMvcModule(IHostingEnvironment env) { _env = env; _appConfiguration = env.GetAppConfiguration(); }
public Startup(IWebHostEnvironment env) { _appConfiguration = env.GetAppConfiguration(); }