public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json"); Configuration = builder.Build(); }
public TemplateService( ILogger <TemplateService> logger, IRazorViewEngine viewEngine, IServiceProvider serviceProvider, ITempDataProvider tempDataProvider, Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment )
public ReportController(IOptions <AppSettings> settings, Microsoft.Extensions.Caching.Memory.IMemoryCache memoryCache, Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment) { _cache = memoryCache; _hostingEnvironment = hostingEnvironment; _connection = settings.Value.PersistanceConnectionString; }
public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); // to do - wire in our HTTP endpoints app.Use(async(ctx, next) => { if (Path.GetExtension(ctx.Request.Path) == ".ts" || Path.GetExtension(ctx.Request.Path) == ".tsx") { await ctx.Response.WriteAsync(File.ReadAllText(ctx.Request.Path.Value.Substring(1))); } else { await next(); } }); } app.UseSignalR(routes => { routes.MapHub <DataNotificationHub>("/hubs/notifications"); }); app.UseStaticFiles(); app.UseMvc(); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider provider) { app.UseForwardedHeaders(); app.UseHsts(); GlobalConfiguration.Configuration.UseActivator(new HangfireActivator(app.ApplicationServices)); app.UseMiddleware <ExceptionMiddleware>(); app.UseHttpsRedirection(); app.UseCors("AllowCors"); app.UseHangfireServer(); app.UseHangfireDashboard(Configuration.GetValue <string>("Hangfire:Path"), new DashboardOptions { Authorization = new[] { provider.GetService <IDashboardAuthorizationFilter>() } }); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); RegisterAsyncServices(provider.GetService <IServiceScopeFactory>()); }
/// <summary> /// Constructor for netstandard /// </summary> public EnvironmentSettings(Microsoft.AspNetCore.Hosting.IHostingEnvironment env) { EnvironmentName = env?.EnvironmentName; ContentRootPath = env?.ContentRootPath; WebRootPath = env?.WebRootPath; ApplicationBasePath = System.AppContext.BaseDirectory; }
public void GlobalSetup() { var mockServices = new Mock <IServiceProvider>(); mockServices .Setup(s => s.GetService(typeof(IHtmlMinificationManager))) .Returns(new HtmlMinificationManager(new NullLogger(), Options.Create(new HtmlMinificationOptions { CssMinifierFactory = new KristensenCssMinifierFactory(), JsMinifierFactory = new CrockfordJsMinifierFactory() }) )) ; mockServices .Setup(s => s.GetService(typeof(IHttpCompressionManager))) .Returns(new HttpCompressionManager(Options.Create(new HttpCompressionOptions()))) ; var mockEnvironment = new Mock <HostingEnvironment>(); mockEnvironment .Setup(m => m.EnvironmentName) .Returns(Environments.Production) ; _services = mockServices.Object; _environment = mockEnvironment.Object; }
public HostingEnvironmentAdapter(Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment) { EnvironmentName = hostingEnvironment.EnvironmentName; ApplicationName = hostingEnvironment.ApplicationName; ContentRootPath = hostingEnvironment.ContentRootPath; ContentRootFileProvider = hostingEnvironment.ContentRootFileProvider; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostEnvironment env, ILoggerFactory loggerFactory) { Logger log = new LoggerConfiguration() .WriteTo.LiteDB($"Logs/log_{DateTime.Now.Date:yyyy-dd-M}.db") .CreateLogger(); loggerFactory.AddSerilog(log, true); loggerFactory.AddFile("Logs/Flubu-{Date}.txt"); app.UseDeveloperExceptionPage(); app.UseAuthentication(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); app.UseStaticFiles(); #if !NETCOREAPP3_1 app.UseSwagger(c => { c.PreSerializeFilters.Add((swagger, httpReq) => swagger.Host = httpReq.Host.Value); }); app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "V1 Docs"); }); #endif }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logging) { #region NLOG NLog.LogManager.LoadConfiguration("nlog.config"); logging.AddNLog(); #endregion app.UseDeveloperExceptionPage(); app.UseWhen( c => c.Request.Path.Value.ToLower().EndsWith("appsettings.json") || c.Request.Path.Value.ToLower().EndsWith(".map"), _ => _.Run((context => context.Response.WriteAsync("503")))); app.UseLogDashboard(); app.UseWhen( c => { var path = c.Request.Path.Value.ToLower(); return(path.EndsWith(".api") || path.EndsWith(".rollback") || path.EndsWith(".upload") || path.EndsWith(".delete") || path.EndsWith(".pathlist") || path.EndsWith(".reupload")); }, _ => _.UseMiddleware <ApiMiddleware>()); app.UseStaticFiles(); app.UseJsEngine(); app.UseMvc(routes => { routes.MapRoute("Admin", "Admin/{*url}", defaults: new { controller = "Home", action = "Admin" }); routes.MapRoute("Spa", "{*url}", defaults: new { controller = "Home", action = "Index" }); }); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); //if (env.IsDevelopment()) //{ // app.UseDeveloperExceptionPage(); //} //else //{ // app.UseExceptionHandler("/Error"); // app.UseHsts(); //} app.UseCors(config => config.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin().AllowCredentials()); app.UseDefaultFiles(); app.UseStaticFiles(); app.UseHttpsRedirection(); app.UseSignalR(routes => { routes.MapHub <PingHub>("/pingHub"); routes.MapHub <StatusOverviewHub>("/overviewHub"); }); // app.UseWebSockets(); app.UseMvc(); }
public BtcTransmuterOptions(IConfiguration configuration, IHostingEnvironment hostingEnvironment, ILogger logger) { DatabaseConnectionString = configuration.GetValue <string>("Database"); DataProtectionDir = configuration.GetValue <string>("DataProtectionDir"); DatabaseType = configuration.GetValue <DatabaseType>("DatabaseType", DatabaseType.Sqlite); ExtensionsDir = configuration.GetValue <string>("ExtensionsDir", Path.Combine(hostingEnvironment.ContentRootPath, "Extensions")); if (DatabaseType == DatabaseType.Sqlite) { var dbFilePath = DatabaseConnectionString.Substring(DatabaseConnectionString.IndexOf("Data Source=") + "Data Source=".Length); dbFilePath = dbFilePath.Substring(0, dbFilePath.IndexOf(";")); if (!string.IsNullOrEmpty(Path.GetDirectoryName(dbFilePath))) { if (DataProtectionDir == null) { DataProtectionDir = Path.GetDirectoryName(dbFilePath); } Directory.CreateDirectory(Path.GetDirectoryName(dbFilePath)); } } logger.LogWarning($"Connecting to {DatabaseType} db with: {DatabaseConnectionString}"); logger.LogWarning($"Extensions Dir: {ExtensionsDir}, Data Protection Dir: {DataProtectionDir}"); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { // add http for Schema at default url /graphql app.UseGraphQL <ProductSchema>(); // use graphql-playground at default url /ui/playground app.UseGraphQLPlayground(new GraphQLPlaygroundOptions()); }
public ReportDesignerAPIController(Microsoft.Extensions.Caching.Memory.IMemoryCache memoryCache, Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment) { _cache = memoryCache; _hostingEnvironment = hostingEnvironment; ExternalServer externalServer = new ExternalServer(_hostingEnvironment); ReportDesignerHelper.ReportingServer = externalServer; }
public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseDeveloperExceptionPage(); app.UseStaticFiles(); app.UseMvc(); app.UseCors("LocalSpa"); app.UseSignalR(route => route.MapHub <ApplicationHub>("/application")); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseServiceModel(builder => { builder.AddService <EchoService>(); builder.AddServiceEndpoint <EchoService, IEchoService>(new BasicHttpBinding(), "/BasicWcfService/basichttp.svc"); }); }
public UpdateCenterController(IGitHubClient client, ITaskFactory taskFactory, IFlubuSession flubuSession, IHostEnvironment hostEnvironment, IHostApplicationLifetime applicationLifetime) { _client = client; _taskFactory = taskFactory; _flubuSession = flubuSession; _hostEnvironment = hostEnvironment; _applicationLifetime = applicationLifetime; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseMiddleware <MetricsPushingMiddleware>(); app.UseMiddleware <ExceptionHandlingMiddleware>(); app.UseMiddleware <RateLimitingMiddleware>(); app.UseMvc(); }
public FileContentService( string textContentDirectoryPath, HostingEnvironment hostingEnvironment ) { _textContentDirectoryPath = textContentDirectoryPath; _hostingEnvironment = hostingEnvironment; }
public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddEncryptedProvider(); builder.AddEnvironmentVariables(); Configuration = builder.Build(); }
public ReportMovimentacaoController(Microsoft.Extensions.Caching.Memory.IMemoryCache memoryCache, Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment, IReportRepository repository, IConfiguration configuration) { _cache = memoryCache; _hostingEnvironment = hostingEnvironment; _repository = repository; _config = configuration; }
protected StartupAbstract(IHostingEnvironment env) { Env = env; var cfgHelper = new ConfigurationHelper(); //加载主机配置项 HostOptions = cfgHelper.Get <HostOptions>("Host", env.EnvironmentName, true); }
public ValuesController(ILogger <ValuesController> logger, Microsoft.AspNetCore.Hosting.IHostingEnvironment e) { this._logger = logger; this._logger.LogInformation("ValuesController ==========="); this._logger.LogDebug($"debug: ApplicationName: {e.ApplicationName} e.WebRootPath: {e.WebRootPath}"); this._logger.LogInformation($"info: ApplicationName: {e.ApplicationName} e.WebRootPath: {e.WebRootPath}"); this._logger.LogError($"error: ApplicationName: {e.ApplicationName} e.WebRootPath: {e.WebRootPath}"); }
public ExpenseController(IExpenseRepository expensesRepository, IAttorneyRepository attorneyRepository, Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment, IActivityRepository activityRepository) { this._expensesRepo = expensesRepository; this._attorneyRepo = attorneyRepository; _hostingEnvironment = hostingEnvironment; this._activityRepo = activityRepository; }
public ServerStartup(Microsoft.AspNetCore.Hosting.IHostingEnvironment env) { var builder = new ConfigurationBuilder() .AddEnvironmentVariables(); Configuration = builder.Build(); }
public virtual void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime appLifetime, IApiVersionDescriptionProvider provider) { app.UseForwardedHeaders(new ForwardedHeadersOptions { ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto }); appLifetime.ApplicationStopping.Register(ProgramBase <TStart> .ConsulConfigCancellationTokenSource.Cancel); app.UseCoreFunctionality(provider, ConfigureSwagger); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseRouting(); app.UseEndpoints(x => { //x.MapControllers(); x.MapJasperEndpoints(); }); }
/// <summary> /// 构造函数 /// </summary> /// <param name="configuration"></param> /// <param name="environment"></param> /// <param name="logger"></param> public Startup( IConfiguration configuration, IHostingEnvironment environment, ILogger <Startup> logger) { _configuration = configuration; _environment = environment; _logger = logger; }
public CoverScreenshotsService(Microsoft.AspNetCore.Hosting.IHostingEnvironment _hostingEnvironment) { //this.options = options; this._hostingEnvironment = _hostingEnvironment; //_service.GetService() //this._dbContext = _dbContext; //this._dbContext = _dbContext; //this._service = _service; }
public Startup(Microsoft.AspNetCore.Hosting.IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables(); Configuration = builder.Build(); }