// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.UseRouting(); // must be below app.UseAuthentication();
//app.UseMvc(); // .net core < 3.0
SwaggerConfiguration.Configure(app);
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IApiVersionDescriptionProvider apiVersionDescriptionProvider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
//app.UseHttpsRedirection();
app.UseRouting();
CorsOrginConfiguration.Configure(app);
app.UseAuthentication();
app.UseAuthorization();
SwaggerConfiguration.Configure(app, SwaggerConfig, apiVersionDescriptionProvider);
app.UseHealthChecks("/hc");
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
/// <summary>
/// Description
/// </summary>
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IOptions <SwaggerConfiguration> swaggerOptions)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
// Enable middleware to serve generated Swagger as a JSON endpoint.
SwaggerConfiguration swagger = swaggerOptions.Value;
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint($"/swagger/{swagger.ApiVersion}/swagger.json", swagger.Title);
});
app.UseHttpsRedirection();
app.UseMvc();
}
private static SwaggerConfiguration GetSwaggerConfiguration(IServiceProvider provider)
{
var swaggerConfigurationOption = provider.GetRequiredService <IOptions <SwaggerConfiguration> >();
SwaggerConfiguration result = swaggerConfigurationOption.Value;
return(result);
}
internal static IApplicationBuilder UseSwaggerDocumentation(this IApplicationBuilder app)
{
IServiceProvider provider = app.ApplicationServices;
app.UseDefaultFiles();
SwaggerConfiguration swaggerConfig = GetSwaggerConfiguration(provider);
app.UsePathBase($"/{swaggerConfig.HostPath}/");
app.UseStaticFiles();
app.UseSwagger(c =>
{
c.PreSerializeFilters.Add((swagger, httpReq) =>
{
var schema = httpReq.Host.Value.Contains("localhost") ? "http" : "https";
swagger.Servers = new List <OpenApiServer> {
new OpenApiServer {
Description = "Uri Base Api",
Url = $"{schema}://{httpReq.Host.Value}" + ((!string.IsNullOrEmpty(swaggerConfig.HostPath)) ? $"/{swaggerConfig.HostPath}" : string.Empty)
}
};
});
});
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint($"{swaggerConfig.EndpointUrl}", swaggerConfig.EndpointDescription);
});
return(app);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var swaggerConfiguration = new SwaggerConfiguration();
Configuration.GetSection(nameof(swaggerConfiguration)).Bind(swaggerConfiguration);
app.UseSwagger(config => { config.RouteTemplate = swaggerConfiguration.JsonRoute; });
app.UseSwaggerUI(config =>
{
config.SwaggerEndpoint(swaggerConfiguration.UiEndpoint, swaggerConfiguration.Description);
});
app.UseCors("CorsPolicy");
//app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public void ConfigureServices(IServiceCollection services)
{
VersioningConfiguration.AddConfiguration(services, 1, 0);
DependencyInjectionConfiguration.RegisterServices(services);
ApiConfiguration.AddConfiguration(services);
SwaggerConfiguration.AddConfiguration(services);
}
/// <summary>
/// Configures the services.
/// </summary>
/// <param name="services">The services.</param>
public void ConfigureServices(IServiceCollection services)
{
ConfigurationOptions.ConfigureService(services, Configuration);
// Add framework services.
services.AddMvc(
options =>
{
options.Filters.Add(typeof(ValidateModelStateAttribute));
});
// Remove commented code and above semicolon
// if the assembly of the API Controllers is different than project which contains Startup class
//.AddApplicationPart(typeof(BaseController<>).Assembly);
// Localization support
LocalizationConfiguration.ConfigureService(services);
Mapper.Reset();
// https://github.com/AutoMapper/AutoMapper.Extensions.Microsoft.DependencyInjection/issues/28
services.AddAutoMapper(typeof(Startup));
// Swagger API documentation
SwaggerConfiguration.ConfigureService(services);
// IOC containers / Entity Framework
EntityFrameworkConfiguration.ConfigureService(services, Configuration);
IocContainerConfiguration.ConfigureService(services, Configuration);
ApiVersioningConfiguration.ConfigureService(services);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
var swaggerConfiguration = new SwaggerConfiguration();
Configuration.GetSection(nameof(swaggerConfiguration)).Bind(swaggerConfiguration);
app.UseSwagger(config => { config.RouteTemplate = swaggerConfiguration.JsonRoute; });
app.UseSwaggerUI(config =>
{
config.SwaggerEndpoint(swaggerConfiguration.UiEndpoint, swaggerConfiguration.Description);
});
app.UseExceptionHandler("/error");
app.UseRequestLocalization();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public void Configure(IApplicationBuilder applicationBuilder, IHostingEnvironment environment)
{
if (environment.IsDevelopment())
{
applicationBuilder.UseDeveloperExceptionPage();
}
else
{
applicationBuilder.UseHsts();
}
Configuration = ConfigurationBuilderConfiguration.Configure(applicationBuilder, environment);
CorsConfiguration.Configure(applicationBuilder);
SwaggerConfiguration.Configure(applicationBuilder);
applicationBuilder
.UseHttpsRedirection()
.UseMvc()
.Run(context =>
{
// Make the Swagger UI be the default when a Controller Action is not found
context.Response.Redirect("swagger");
return(Task.CompletedTask);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <KorepetycjeContext>(options =>
options.UseSqlServer(this.Configuration.GetConnectionString("DefaultConnection")));
KorepetycjeContext.ConnectionString = this.Configuration.GetConnectionString("DefaultConnection");
SwaggerConfiguration.RegisterService(services);
CorsConfiguration.Register(services,
Configuration.GetSection(nameof(CorsConfigurationValues)).Get <CorsConfigurationValues>());
services.AddIdentity <User, IdentityRole <int> >()
.AddEntityFrameworkStores <KorepetycjeContext>()
.AddDefaultTokenProviders();
services.RegisterBearerPolicy(Configuration);
services.AddMvc()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddAutoMapper(); // Register AutoMapper
RegisterServices(services);
RegisterRepositories(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//Setup para configuração do Swagger
SwaggerConfiguration.AddSwagger(services);
//Setup para configuração do EntityFramework
EntityFrameworkConfiguration.AddEntityFramework(services, Configuration);
//Setup para configuração do JWT
JwtConfiguration.ConfigureServices(services, Configuration);
//Setup para o MongoDB
MongoDBConfiguration.AddMongoDBSetup(services, Configuration);
//Injeção de dependência
DependencyInjectionConfiguration.AddDependencyInjection(services);
//Setup para o MediatR
MediatRConfiguration.AddMediatRSetup(services);
//Setup para o AutoMapper
AutoMapperConfiguration.AddAutoMapperSetup(services);
//Setup para o CORS
CorsConfiguration.AddCors(services);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
SwaggerConfiguration.Configure(app, Configuration);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseSerilogRequestLogging();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "MyArea",
template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
//configuração de CORS
CorsConfiguration.UseCors(app);
//configuração do JWT
JwtConfiguration.UseJwt(app);
//configuração do swagger
SwaggerConfiguration.UseSwagger(app);
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
/// <summary>
/// Description
/// </summary>
public void ConfigureServices(IServiceCollection services)
{
services.AddCommonEngine();
IConfigurationSection swaggerSection = Configuration.GetSection("Swagger");
services.Configure <SwaggerConfiguration>(swaggerSection);
SwaggerConfiguration swagger = swaggerSection.Get <SwaggerConfiguration>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc(swagger.ApiVersion, new Info
{
Title = swagger.Title,
Version = swagger.ApiVersion,
Contact = new Contact
{
Name = swagger.ContactName,
Email = swagger.ContactMail,
Url = swagger.ContactUrl
},
Description = swagger.Description,
License = new License
{
Name = swagger.LicenseName,
Url = swagger.LicenseUrl
},
TermsOfService = swagger.TermsOfService
});
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
using (KorepetycjeContext context = new KorepetycjeContext())
{
context.Database.Migrate();
}
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
DatabaseSeed.Initialize(app.ApplicationServices.GetRequiredService <IServiceScopeFactory>().CreateScope().ServiceProvider);
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseCors(CorsConfiguration.CorsPolicyName);
app.UseMvc();
app.UseSwagger();
SwaggerConfiguration.RegisterUi(app);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// Enable CORS
// Set it before of enable MVC
services.AddCors();
// Add framework services.
services.AddMvc();
// Setup options with DI
services.AddOptions();
// Setup Swagger
services.AddSwaggerGen();
SwaggerConfiguration.AddSwagger(services);
// Configuration Properties
services.Configure <MySqlDataSourcePropertyConfiguration>(Configuration.GetSection("DatabaseConfiguration"));
// Create the container builder.
var builder = new ContainerBuilder();
RepositoryConfiguration.AddRepositories(builder);
ServiceConfiguration.AddServices(builder);
builder.Populate(services);
this.ApplicationContainer = builder.Build();
// Create the IServiceProvider based on the container.
return(new AutofacServiceProvider(this.ApplicationContainer));
}
/// <summary>
///
/// </summary>
/// <param name="services"></param>
public void ConfigureServices(IServiceCollection services)
{
SwaggerConfiguration.AddService(services);
DbContextExtension.AddService(services, Configuration);
CorsExtension.AddService(services);
RouteExtension.AddService(services);
RouteAnalyzerExtension.AddService(services);
services.AddMemoryCache();
services.AddHttpContextAccessor();
services.AddSingleton <IActionContextAccessor, ActionContextAccessor>();
try
{
#pragma warning disable 618
AuthenticationConfiguration.AddService(services, Configuration);
services.AddAutoMapper();
#pragma warning disable 618
}
catch
{
}
WebEncoderConfiguration.AddService(services);
ValidateConfiguration.AddService(services);
JsonExtension.AddService(services);
SetCompatibilityVersionExtension.AddService(services);
}
private void ConfigureSwagger(IServiceCollection services)
{
var swaggerConfiguration = new SwaggerConfiguration();
this.configuration.Bind("Swagger", swaggerConfiguration);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = swaggerConfiguration.Version,
Title = swaggerConfiguration.Title,
Description = swaggerConfiguration.Description,
Contact = new OpenApiContact
{
Email = swaggerConfiguration.Email,
},
});
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
c.EnableAnnotations();
c.OperationFilter <AddResponseHeadersFilter>();
c.AddSecurityDefinition("jwtBearerAuth", new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
Scheme = "bearer",
BearerFormat = "JWT"
});
c.OperationFilter <Filters.SecurityRequirementsOperationFilter>();
});
services.Configure <EventHubLoggingConfiguration>(configuration.GetSection("EventHubLoggingConfiguration"));
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
MigrationsExecuteConfiguration.UpdateDatabase(app);
SwaggerConfiguration.AddSwaggerApplicationBuilder(app);
app.UseRouting();
app.UseCors(x => x
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public void ConfigureServices(IServiceCollection services)
{
ConfigurationOptions.ConfigureService(services, Configuration);
services.AddMvc(
options =>
{
options.Filters.Add(typeof(ValidateModelStateAttribute));
});
Mapper.Reset();
services.AddAutoMapper(typeof(Startup)); // Swagger API documentation
SwaggerConfiguration.ConfigureService(services);
EntityFrameworkConfiguration.ConfigureService(services, Configuration);
IocContainerConfiguration.ConfigureService(services, Configuration);
ApiVersioningConfiguration.ConfigureService(services);
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = "JwtBearer";
options.DefaultChallengeScheme = "JwtBearer";
})
.AddJwtBearer("JwtBearer", jwtBearerOptions =>
{
jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Constants.SymmetricSecurityKey)),
ValidateIssuer = false,
ValidateAudience = false,
ValidateLifetime = true, //validate the expiration and not before values in the token
ClockSkew = TimeSpan.FromMinutes(5) //5 minute tolerance for the expiration date
};
jwtBearerOptions.Events = new JwtBearerEvents
{
OnTokenValidated = context =>
{
var slug = context.HttpContext.Request.Headers[Constants.TenantId].ToString();
if (context.SecurityToken is JwtSecurityToken accessToken && !string.IsNullOrWhiteSpace(slug))
{
if (accessToken.Claims.Where(claim => claim.Type.Equals(ClaimTypes.PrimaryGroupSid)).Any(claim => slug == claim.Value))
{
return(Task.CompletedTask);
}
}
context.Fail($"Invalid 'slug'");
return(Task.CompletedTask);
}
};
});
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <ForwardedHeadersOptions>(options =>
{
options.KnownProxies.Add(IPAddress.Parse("10.0.0.100"));
});
//Configure loging
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(Configuration)
.WriteTo.Console()
.CreateLogger();
services.AddSingleton(Log.Logger);
//Configure db context
EntityFrameworkConfiguration.ConfigureService(services, Configuration);
//Add auto mapper on start up
services.AddAutoMapper(typeof(Startup));
//Configure dependency injection
IocContainerConfiguration.ConfigureService(services);
//Configure jwt
JwtConfiguration.ConfigureService(services, Configuration);
// Configure your policies
services.AddAuthorization(options =>
{
options.AddPolicy(nameof(Role.SuperAdmin),
policy => policy.RequireClaim(nameof(Role.SuperAdmin)));
options.AddPolicy(nameof(Role.Administrator),
policy => policy.RequireClaim(nameof(Role.Administrator)));
options.AddPolicy(nameof(Role.User),
policy => policy.RequireClaim(nameof(Role.User)));
});
// Configure action filter attribute
services.AddControllers(opt =>
{
opt.Filters.Add(typeof(ValidateModel));
});
// Configure enforce lowercase routing
services.AddRouting(options => options.LowercaseUrls = true);
SwaggerConfiguration.ConfigureService(services);
// Config for upload file
services.Configure <FormOptions>(o => {
o.ValueLengthLimit = int.MaxValue;
o.MultipartBodyLengthLimit = int.MaxValue;
o.MemoryBufferThreshold = int.MaxValue;
});
// Config Api Version
services.AddApiVersioning();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson();
services.AddDbContext <AmandaStoreDBContext>();
DependencyInjection.Dependencias(services);
SwaggerConfiguration.Configure(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddDbContext <PHContext>(options => options.UseSqlServer(Configuration.GetConnectionString("PHConnectionString")));
SwaggerConfiguration.ConfigureServices(services);
DependencyInjection.Configure(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddMvc();
// Configuring Swagger
SwaggerConfiguration.ConfigureSwagger(services);
}
public void ConfigureServices(IServiceCollection services)
{
VersioningConfiguration.AddConfiguration(services, 1, 0);
SwaggerConfiguration.AddConfiguration(services);
IdentityConfiguration.AddConfiguration(services, Configuration.GetConnectionString("IdentityConnection"));
ApiConfiguration.AddConfiguration(services);
DependencyInjectionConfiguration.RegisterServices(services);
}
public static void AddConfiguration(this IServiceCollection service)
{
DBConfiguration.Register(service);
RepositoriesDI.Register(service);
ServicesDI.Register(service);
CorsConfiguration.RegisterCors(service);
SwaggerConfiguration.RegisterSwagger(service);
}
internal static IServiceCollection AddSwagger(
this IServiceCollection services,
IConfiguration config)
{
var configuration = new SwaggerConfiguration();
config.Bind(configuration);
if (!Uri.TryCreate(configuration.AuthorizationUrl, UriKind.Absolute, out var authorizationUri))
{
throw new UriFormatException($"Wrong format AuthorizationUrl: {configuration.AuthorizationUrl}");
}
if (!Uri.TryCreate(configuration.TokenUrl, UriKind.Absolute, out var tokenUri))
{
throw new UriFormatException($"Wrong format TokenUrl: {configuration.TokenUrl}");
}
return(services
.AddSwaggerGen(c =>
{
c.SwaggerDoc(Version, new OpenApiInfo {
Title = "Flights API", Version = Version
});
c.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"));
c.AddSecurityDefinition(SecurityDefinitionName, new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OAuth2,
Flows = new OpenApiOAuthFlows
{
Implicit = new OpenApiOAuthFlow
{
AuthorizationUrl = authorizationUri,
TokenUrl = tokenUri,
Scopes = new Dictionary <string, string>
{
{ configuration.ScopeName, "scope for flights" }
}
}
}
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = SecurityDefinitionName
}
},
new string[] {}
}
});
c.SchemaFilter <SchemaFilter>();
}));
}
private static SwaggerConfiguration GetOptions(
IConfiguration configuration)
{
var result = new SwaggerConfiguration();
configuration.GetSection(nameof(SwaggerConfiguration)).Bind(result);
return(result);
}
public void ConfigureServices(IServiceCollection services)
{
SimpleInjectorConfiguration.ConfigureServices(services, _configuration);
CorsConfiguration.ConfigureServices(services);
MvcConfiguration.ConfigureServices(services);
SwaggerConfiguration.ConfigureServices(services);
HangfireConfiguration.ConfigureServices(services, _configuration);
DatabaseConfiguration.ConfigureServices(services, _configuration);
}
