public TokenService(SigninConfiguration signingConfiguration,
TokenConfiguration tokenConfigurations, IConfiguration configuration)
{
_signingConfiguration = signingConfiguration;
_tokenConfigurations = tokenConfigurations;
_configuration = configuration;
}
public LoginService(IPessoaRepository repository,
SigninConfiguration signinConfiguration,
TokenConfiguration tokenConfiguration,
IRefreshTokenRepository refreshTokenRepository)
{
_pessoaRepository = repository;
_signingConfiguration = signinConfiguration;
_tokenConfiguration = tokenConfiguration;
_refreshTokenRepository = refreshTokenRepository;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigureService.ConfigureDependenceService(services);
ConfigureRepository.ConfigureDependenceRepository(services);
var signingConfigurations = new SigninConfiguration();
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>
(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfiguration);
var tokenService = new TokenService(signingConfigurations, tokenConfiguration, Configuration);
services.AddSingleton(tokenService);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.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.AddControllers();
}
public LoginBusiness(IUserRepository repository, SigninConfiguration signinConfiguration, TokenConfiguration tokenConfiguration)
{
this.repository = repository;
this.signinConfiguration = signinConfiguration;
this.tokenConfiguration = tokenConfiguration;
}
public WalletModule(IServiceCollection services, IConfiguration configuration)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
// jwt configuration
var siginConfiguration = new SigninConfiguration(configuration.GetValue <string>("Security:Key"));
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
configuration.GetSection("Token")).Configure(tokenConfiguration);
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
var paramsValidation = options.TokenValidationParameters;
paramsValidation.IssuerSigningKey = siginConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
// validate token signature
paramsValidation.ValidateIssuerSigningKey = true;
// validate token lifetime
paramsValidation.ValidateLifetime = true;
// set tolerance time for token expiration
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// configure access authorization
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
// HTTP Context
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
// data source
services.AddScoped <IDataSource>(provider =>
new DefaultDataSource(configuration, "DefaultSQL"));
// unit of work
services.AddScoped <IUnitOfWorkAsync, WalletContext>();
// repositories
services.AddScoped <IAccountRepository, AccountRepository>();
services.AddScoped <IWalletBlockchainRepository>(provider =>
new WalletBlockchainRepository(configuration.GetConnectionString("DefaultNoSQL")));
// services
services.AddScoped <IWalletBlockchainService, WalletBlockchainService>();
// commands
services.AddScoped <IAccountsCommandHandler, AccountsCommandHandler>();
// queries
services.AddScoped <IAccountsQueryHandler, AccountsQueryHandler>();
// app services
services.AddScoped <IAccountsAppService, AccountsAppService>();
}
// 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);
// Configurações CORS
CorsPolicyBuilder corsBuilder = new CorsPolicyBuilder();
corsBuilder.AllowAnyHeader();
corsBuilder.AllowAnyMethod();
corsBuilder.AllowAnyOrigin();
corsBuilder.AllowCredentials();
services.AddCors(options =>
{
options.AddPolicy("SiteCorsPolicy", corsBuilder.Build());
});
//injetando contexto do banco de dados
services.AddDbContext <Context>(options => options.UseSqlServer(Configuration.GetConnectionString("MeetingRoom")));
//injetando classes
services.AddScoped <ISalaService, SalaService>();
services.AddScoped <ISalaRepository, SalaRepository>();
services.AddScoped <IPessoaService, PessoaService>();
services.AddScoped <IPessoaRepository, PessoaRepository>();
services.AddScoped <IReservaService, ReservaService>();
services.AddScoped <IReservaRepository, ReservaRepository>();
services.AddScoped <IRefreshTokenRepository, RefreshTokenRepository>();
services.AddScoped <ILoginService, LoginService>();
//configurações para a utiulização de JWT
var signinConfiguration = new SigninConfiguration();
services.AddSingleton(signinConfiguration);//apenas uma instancia enquanto a aplicação estiver executando
var configToken = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfigurations") //busca confiugurações do token em appsettings.json
).Configure(configToken);
services.AddSingleton(configToken);
services.AddAuthentication(auth =>
{
auth.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
auth.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(beareroptions =>
{
var parametrosValidacao = beareroptions.TokenValidationParameters;
parametrosValidacao.IssuerSigningKey = signinConfiguration.Key;
parametrosValidacao.ValidAudience = configToken.Audience;
parametrosValidacao.ValidIssuer = configToken.Issuer;
// Valida a assinatura de um token recebido
parametrosValidacao.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
parametrosValidacao.ValidateLifetime = true;
// Tempo de tolerância para a expiração de um token (usado no caso de
// de problemas de sincronização de tempo entre diferentes
// computadores envolvidos no processo de comunicação)
parametrosValidacao.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
// Configurando o serviço de documentação do Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new Info
{
Title = "API salas de reuniões",
Version = "v1",
Description = "Back end para gerenciamento dos agendamentos das salas de reuniões",
Contact = new Contact
{
Name = "Desenvolvedor: Willian Menezes dos Santos.",
Url = "https://www.linkedin.com/in/willian-menezes-9932b1b9/"
}
});
});
}
// 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));
ExecuteMigrations(connectionString);
var sigingConfiguration = new SigninConfiguration();
services.AddSingleton(sigingConfiguration);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfiguration")
)
.Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOtpions => {
authOtpions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOtpions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions => {
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = sigingConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issue;
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateLifetime = true;
//Pode ser alterado para resolver problemas de sincronização
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
//adicionando suporte a xml, por padrão já tinhamos o json
services.AddMvc(options =>
{
options.RespectBrowserAcceptHeader = true;
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json"));
})
.AddXmlSerializerFormatters()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var filterOptions = new HyperMediaFilterOptions();
filterOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
services.AddSingleton(filterOptions);
services.AddSwaggerGen(o =>
{
o.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info {
Title = "RESTfull API With ASP.Net Core 2.0", Version = "v1"
});
});
services.AddApiVersioning();
//Injeção de dependencia
services.AddScoped <IPersonBusiness, PersonBusiness>();
services.AddScoped <IBookBusiness, BookBusiness>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <ILoginBusiness, LoginBusiness>();
services.AddScoped <IFileBusiness, FileBusiness>();
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
services.AddScoped <IPersonRepository, PersonRepository>();
}
public IdentityModule(IServiceCollection services, IConfiguration configuration)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
// jwt configuration
var siginConfiguration = new SigninConfiguration(configuration.GetValue <string>("Security:Key"));
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
configuration.GetSection("Token")).Configure(tokenConfiguration);
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
var paramsValidation = options.TokenValidationParameters;
paramsValidation.IssuerSigningKey = siginConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
// validate token signature
paramsValidation.ValidateIssuerSigningKey = true;
// validate token lifetime
paramsValidation.ValidateLifetime = true;
// set tolerance time for token expiration
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// configure access authorization
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
// HTTP Context
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
// data source
services.AddSingleton <IDataSource>(provider =>
new DefaultDataSource(configuration, "IdentityDb"));
// unit of work
services.AddScoped <IUnitOfWorkAsync, IdentityContext>();
// providers
// cache
services.AddSingleton <ICacheService>(provider =>
new RedisCacheService(configuration.GetValue <string>("Redis:Endpoint"),
configuration.GetValue <int>("Redis:Database"))
{
Expires = TimeSpan.FromSeconds(configuration.GetValue <int>("Redis:Expires"))
});
services.AddSingleton(provider =>
new CacheConfiguration(configuration.GetValue <string>("Redis:CacheKey")));
// security token
services.AddScoped <ISecurityTokenService>(provider =>
new SecurityTokenService(siginConfiguration, tokenConfiguration));
// repositories
services.AddScoped <IUserRepository, UserRepository>();
// command handlers
services.AddScoped <IUserCommandHandler, UserCommandHandler>();
// query handlers
services.AddScoped <IUserQueryHandler, UserQueryHandler>();
// app services
services.AddScoped <IUserAppService, UserAppService>();
}
