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();
}
