// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient <IFriendsService, FriendsService>();
services.AddTransient <ICalculoHistoricoLogService, CalculoHistoricoLogService>();
services.AddTransient <IUserService, UserServices>();
services.AddTransient <ITokenHandler, TokenHandler>();
services.AddScoped <IPasswordHasher, PasswordHasher>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
var signingConfigurations = new SigninConfigurations();
services.AddSingleton(signingConfigurations);
IdentityModelEventSource.ShowPII = true;
services.Configure <TokenOptions>(Configuration.GetSection("TokenOptions"));
var tokenOptions = Configuration.GetSection("TokenOptions").Get <TokenOptions>();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(jwtBearerOptions =>
{
jwtBearerOptions.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = tokenOptions.Issuer,
ValidAudience = tokenOptions.Audience,
IssuerSigningKey = signingConfigurations.Key,
ClockSkew = TimeSpan.Zero
};
});
}
public LoginService(IUserRepository repository, IMapper mapper, SigninConfigurations signinConfigurations, IConfiguration configuration)
{
_repository = repository;
_signinConfigurations = signinConfigurations;
_configuration = configuration;
_mapper = mapper;
}
public LoginBusiness(IUserRepository repository,
SigninConfigurations signinConfigurations,
TokenConfiguration tokenConfiguration)
{
_repository = repository;
_signinConfigurations = signinConfigurations;
_tokenConfiguration = tokenConfiguration;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// É atribuida a string de conexão configurada no appsettings.json
var connectionString = _configuration["MySqlConnection:MySqlConnectionString"];
// Adiciona o contexto do MySQL
services.AddDbContext <MySQLContext>(Options => Options.UseMySql(connectionString));
// Chama um método para funcionar o Migration / Logger
ExecuteMigrations(connectionString);
// ---------------------------------------------------------------------------------
// Inicia o código para funcionar o JWT TOKEN
var signingConfigurations = new SigninConfigurations();
// Adiciona a injeção de dependencia
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfiguration();
// Pega do appsettings.json as configurações do Token
new ConfigureFromConfigurationOptions <TokenConfiguration>(
_configuration.GetSection("TokenConfigurations")
)
.Configure(tokenConfigurations);
// Adiciona a injeção de dependencia
services.AddSingleton(tokenConfigurations);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
paramsValidation.ValidAudience = tokenConfigurations.Audience;
paramsValidation.ValidIssuer = tokenConfigurations.Issuer;
// Validates the signing of a received token
paramsValidation.ValidateIssuerSigningKey = true;
// Checks if a received token is still valid
paramsValidation.ValidateLifetime = true;
// Tolerance time for the expiration of a token (used in case
// of time synchronization problems between different
// computers involved in the communication process)
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// Enables the use of the token as a means of
// authorizing access to this project's resources
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
// ---------------------------------------------------------------------------------
// Adiciona ao código o versionamento de Api's
services.AddApiVersioning(option => option.ReportApiVersions = true);
// Configuração do Swagger para documentação da API
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new Info
{
Title = "RESTFull API with ASP.NET Core 2.1",
Version = "v1"
});
});
// Adiciona o Content Negotiation a API, para receber os dados em xml e json
services.AddMvc(options =>
{
options.RespectBrowserAcceptHeader = true;
options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json"));
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
})
// Desativado por enquanto o suporte a xml
//.AddXmlSerializerFormatters()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
// Injeção de dependência das classes PersonBusiness
services.AddScoped <IPersonBusiness, PersonBusiness>();
// Injeção de dependência das classes LoginBusiness
services.AddScoped <ILoginBusiness, LoginBusiness>();
// Injeção de dependência das classes UserRepository
services.AddScoped <IUserRepository, UserRepository>();
// Injeção de de dependência das classes BookBusiness
services.AddScoped <IBookBusiness, BookBusiness>();
// Injeção de dependência das classes Repository genéricas
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
// Injeção de de dependência das classes PersonRepository
services.AddScoped <IPersonRepository, PersonRepository>();
// Injeção de de dependência das classes FileBusiness
services.AddScoped <IFileBusiness, FileBusiness>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration["MySqlConnection:MySqlConnectionString"];
services.AddDbContext <MySQLContext>(options => options.UseMySql(connectionString));
services.AddApiVersioning();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
{
Title = "Rest Api With ASP.NET Core",
Version = "v1"
});
});
ExecuteMigrations(connectionString);
var signingConfigurations = new SigninConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfigurations")
)
.Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
paramsValidation.ValidAudience = tokenConfigurations.Audience;
paramsValidation.ValidIssuer = tokenConfigurations.Issuer;
// Validates the signing of a received token
paramsValidation.ValidateIssuerSigningKey = true;
// Checks if a received token is still valid
paramsValidation.ValidateLifetime = true;
// Tolerance time for the expiration of a token (used in case
// of time synchronization problems between different
// computers involved in the communication process)
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// Enables the use of the token as a means of
// authorizing access to this project's resources
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddMvc(options =>
{
options.RespectBrowserAcceptHeader = true;
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("application/json"));
}).AddXmlSerializerFormatters();
services.AddScoped <IPersonBusiness, PersonBusiness>();
services.AddScoped <IBookBusiness, BookBusiness>();
services.AddScoped <ILoginBusiness, LoginBusiness>();
services.AddScoped <IFileBusiness, FileBusiness>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IPersonRepository, PersonRepository>();
var filterOptions = new HyperMediaFilterOptions();
filterOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
services.AddSingleton(filterOptions);
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigureService.ConfigureDependenciesService(services);
ConfigureRepository.ConfigureDependenciesRepository(services);
var config = new AutoMapper.MapperConfiguration(cfg =>
{
cfg.AddProfile(new DtoToModelProfile());
cfg.AddProfile(new EntityToDtoProfile());
cfg.AddProfile(new ModelToEntityProfile());
});
IMapper mapper = config.CreateMapper();
services.AddSingleton(mapper);
var signinConfiguration = new SigninConfigurations();
services.AddSingleton(signinConfiguration);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfiguration")).Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signinConfiguration.Key;
paramsValidation.ValidAudience = Environment.GetEnvironmentVariable("Audience");
paramsValidation.ValidIssuer = Environment.GetEnvironmentVariable("Issuer");
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateLifetime = true;
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddControllers();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "Clean Architecture c# DDD",
Description = "Arquitetura DDD",
Contact = new OpenApiContact
{
Name = "Kako",
Email = "*****@*****.**",
Url = new Uri("https://github.com/KakoF")
}
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "Entre com o Token JWT",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference {
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>()
}
});
});
}
public AuthenticationService(TokenConfiguration tokenConfigurations, SigninConfigurations signinConfigurations)
{
_tokenConfiguration = tokenConfigurations;
_signinConfigurations = signinConfigurations;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = _configuration["MySqlConnection:MySqlConnectionString"];
services.AddDbContext <MySQLContext>(options => options.UseMySql(connectionString));
if (_environment.IsDevelopment())
{
try {
var evolveConnection = new MySql.Data.MySqlClient.MySqlConnection(connectionString);
var evolve = new Evolve.Evolve("evolve.json", evolveConnection, msg => _logger.LogInformation(msg))
{
Locations = new List <string> {
"db/migrations"
},
IsEraseDisabled = true,
};
evolve.Migrate();
} catch (Exception ex) {
_logger.LogCritical("Database migration failed.", ex);
throw;
}
}
var siginConfigurations = new SigninConfigurations();
services.AddSingleton(siginConfigurations);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
_configuration.GetSection("TokenConfiguration")).Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions => {
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions => {
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = siginConfigurations.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateLifetime = true;
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth => {
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddMvc(options => {
options.RespectBrowserAcceptHeader = true;
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json"));
})
.AddXmlSerializerFormatters();
var filterOptions = new HyperMediaFilterOptions();
//filterOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
//filterOptions.ObjectContentResponseEnricherList.Add(new BookEnricher());
services.AddSingleton(filterOptions);
services.AddApiVersioning(option => option.ReportApiVersions = true);
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1",
new Info {
Title = "RESTful API with ASP.NET Core 2.0",
Version = "v1"
});
});
//Dependency Injection
services.AddScoped <IPersonBusiness, PersonBusinessImplementation>();
services.AddScoped <IBookBusiness, BookBusinessImplementation>();
services.AddScoped <ILoginBusiness, LoginBusinessImplementation>();
services.AddScoped <IFileBusiness, FileBusinessImplementation>();
services.AddScoped <IUserRepository, UserRepositoryImplementation>();
services.AddScoped <IPersonRepository, PersonRepositoryImplementation>();
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
}
/// <summary>
/// AddJwtAuthorization
/// </summary>
/// <param name="services"></param>
public void AddJwtAuthorization(IServiceCollection services)
{
var signinConfigurations = new SigninConfigurations(Configuration);
services.AddSingleton(signinConfigurations);
var tokenConfigurations = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfigurations")
).Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
var tokenValidationParameters = new TokenValidationParameters
{
ValidAudience = tokenConfigurations.Audience,
ValidIssuer = tokenConfigurations.Issuer,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tokenConfigurations.SecurityKey)),
ValidateIssuerSigningKey = true,
ValidateLifetime = false,
ValidateAudience = true,
ValidateIssuer = true,
ClockSkew = TimeSpan.Zero,
AuthenticationType = "Bearer"
};
services.AddSingleton(tokenValidationParameters);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
bearerOptions.SaveToken = true;
bearerOptions.TokenValidationParameters = tokenValidationParameters;
bearerOptions.RequireHttpsMetadata = true;
bearerOptions.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
return(Task.CompletedTask);
},
OnTokenValidated = context =>
{
return(Task.CompletedTask);
}
};
});
// Ativa o uso do token como forma de autorizar o acesso
// a recursos deste projeto
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
}
