public SeguradoService(SigningConfiguration signingConfiguration,
TokenConfiguration tokenConfiguration,
IConfiguration configuration,
ISeguradoRepository seguradoRepository) : base(seguradoRepository)
{
}
// 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);
ServiceProvider serviceProvider = services.BuildServiceProvider();
IHostingEnvironment env = serviceProvider.GetService <IHostingEnvironment>();
if (env.IsProduction())
{
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
}
// Avoid multiparty Body Lenght Error
services.Configure <FormOptions>(o => {
o.ValueLengthLimit = int.MaxValue;
o.MultipartBodyLengthLimit = int.MaxValue;
o.MemoryBufferThreshold = int.MaxValue;
});
// -----------------------------Injeção de dependência-----------------------------
// Contexto
services.AddDbContext <dbSiteMercadoContext>(options => options.UseSqlServer(Configuration.GetConnectionString("dbsiteMercado")));
//Usuário
services.AddScoped <IUserService, UserService>();
services.AddScoped <IUserRepository, UserRepository>();
// Produtos
services.AddScoped <IProdutosService, ProdutosService>();
services.AddScoped <IProdutosRepository, ProdutosRepository>();
// Imagem
services.AddScoped <IImageRepository, ImageRepository>();
// -----------------------------Autenticação JWT-----------------------------
var signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("TokenConfigurations")
)
.Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.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());
});
}
public UsuarioController(IUsuarioService service, SigningConfiguration signingConfiguration, TokenConfiguration tokenConfiguration)
: base(service)
{
_signingConfiguration = signingConfiguration;
_tokenConfiguration = tokenConfiguration;
}
public object Post([FromBody] User user, [FromServices] FakeUserRepository repository, [FromServices] SigningConfiguration signingConfigurations, [FromServices] Token token)
{
bool validCredentials = false;
if (user == null)
{
return new { authenticated = false, message = "Failed to authenticate!" }
}
;
User userFromDatabase = repository.Find(user.Id);
if (userFromDatabase == null)
{
return new { authenticated = false, message = "Failed to authenticate!" }
}
;
validCredentials = (userFromDatabase != null && userFromDatabase.AccessKey == user.AccessKey);
if (!validCredentials)
{
return new { authenticated = false, message = "Failed to authenticate!" }
}
;
var obj = TokenProvider.GetToken(user, token, signingConfigurations);
return(obj);
}
}
}
/// <summary>
/// Initializes a new instance of the
/// </summary>
/// <param name="repository">Repository.</param>
/// <param name="signingConfigurations">Signing configurations.</param>
/// <param name="tokenConfiguration">Token configuration.</param>
public LoginBusinessImpl(ILoginRepository repository, SigningConfiguration signingConfigurations, TokenConfiguration tokenConfiguration)
{
_repository = repository;
_signingConfiguration = signingConfigurations;
_tokenConfiguration = tokenConfiguration;
}
public SendCommand(SendOptions option, IXadesService xadesService, SigningConfiguration signingConfig, GisServiceConfiguration serviceConfig)
: base(option, xadesService, signingConfig, serviceConfig)
{
}
// 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));
//Login
var signingConfigurations = new SigningConfiguration();
services.AddSingleton(signingConfigurations);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
_configuration.GetSection("TokenConfigurtion")
).Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
paramsValidation.ValidAudience = tokenConfiguration.Aundience;
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());
});
if (!_environment.IsDevelopment())
{
try
{
var evolveConnection = new MySql.Data.MySqlClient.MySqlConnection(connectionString);
var evolve = new Evolve.Evolve(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;
}
}
services.AddControllers();
services.AddApiVersioning();
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "RESTFul API with ASP.NET Core", Version = "v1"
});
});
var filterOptions = new HyperMediaFilterOptions();
filterOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
services.AddSingleton(filterOptions);
//Dependency Injection
services.AddScoped <IPersonBusiness, PersonBusinessImpl>();
services.AddScoped <IBookBusiness, BookBusinessImpl>();
services.AddScoped <ILoginBusiness, LoginBusinessImpl>();
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
services.AddScoped <IUserRepository, UserRepositoryImpl>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigureService.ConfigureDependeciesService(services);
ConfigureRepository.configureDependenceRepository(services);
var signingConfigurations = new SigningConfiguration();
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(barerOptions =>
{
var paramsValidation = barerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
paramsValidation.ValidAudience = tokenConfigurations.Audience;
paramsValidation.ValidIssuer = tokenConfigurations.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();
var config = new AutoMapper.MapperConfiguration(
config =>
{
config.AddProfile(new DtoToModelProfile());
config.AddProfile(new EntityToDtoProfile());
config.AddProfile(new ModelToEntityProfile());
}
);
IMapper mapper = config.CreateMapper();
services.AddSingleton(mapper);
services.AddSwaggerGen(
configuration =>
{
configuration.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "Aprendendo DDD",
Description = "Arquitetura DDD",
TermsOfService = new Uri("http://www.cin.ufpe.br/~ans3"),
Contact = new OpenApiContact
{
Name = "Adriano Santana",
Email = "*****@*****.**",
Url = new Uri("http://www.cin.ufpe.br/~ans3")
}
});
configuration.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "Inserir token Jwt",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
configuration.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference {
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>()
}
});
}
);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connection = Configuration["TicketConnection:ConnectionString"];
services.AddDbContext <TicketContext>(options => options.UseSqlServer(connection));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfiguration.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.AddScoped <IPersonBusiness, PersonBusinessImpl>();
services.AddScoped <ILoginBusiness, LoginBusinessImpl>();
services.AddScoped <IBookBusiness, BookBusinessImpl>();
//services.AddScoped<IPersonRepository, PersonRepositoryImpl>();
services.AddScoped(typeof(IRepository <>), typeof(RepositoryImpl <>));
services.AddScoped <IUserRepository, UserRepositoryImpl>();
services.AddSwaggerGen(c =>
{
c.EnableAnnotations();
c.SwaggerDoc("v1",
new Info
{
Title = "API ASP.NET Core",
Version = "v1"
});
});
services.AddApiVersioning();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
if (_environment.IsEnvironment("Testing"))
{
Environment.SetEnvironmentVariable("DB_CONNECTION", "Persist Security Info=True;Server=localhost;Port=3306;Database=dbApi_Integration;Uid=root;Pwd=joaopjk");
Environment.SetEnvironmentVariable("DATABASE", "MYSQL");
Environment.SetEnvironmentVariable("MIGRATION", "APLICAR");
Environment.SetEnvironmentVariable("Audience", "ExemploAudience");
Environment.SetEnvironmentVariable("Issuer", "ExemploIssuer");
Environment.SetEnvironmentVariable("Seconds", "12000");
}
ConfigureService.ConfigureDependenciesService(services);
ConfigureRepository.ConfigureDependenciesRepository(services);
var singning = new SigningConfiguration();
services.AddSingleton(singning);
var tokenConfiguration = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
Configuration.GetSection("TokenConfigurations"))
.Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddControllers();
var config = new AutoMapper.MapperConfiguration(config =>
{
config.AddProfile(new DtoToModelProfile());
config.AddProfile(new EntityToDtoProfile());
config.AddProfile(new ModelToEntityProfile());
});
IMapper mapper = config.CreateMapper();
services.AddSingleton(mapper);
services.AddAuthentication(auth =>
{
auth.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
auth.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(Options =>
{
var paramsValidation = Options.TokenValidationParameters;
paramsValidation.IssuerSigningKey = singning.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateLifetime = false;
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "App", Version = "v1"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "Entre com o JWT Token ",
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 UserService(SigningConfiguration signingConfiguration, IUserRepository userRepository)
{
_signingConfiguration = signingConfiguration;
_userRepository = userRepository;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(x =>
{
x.AddPolicy("EnableCORS", y => { y.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod(); });
});
var token = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(Configuration.GetSection(typeof(TokenConfiguration).Name)).Configure(token);
services.AddSingleton(token);
var signingConfiguration = new SigningConfiguration(token);
services.AddSingleton(signingConfiguration);
services.AddDbContext <ErrorHubContext>();
services.AddHttpContextAccessor();
services.AddSingleton <IAuthenticationService, JwtAuthenticationService>();
services.AddSingleton <ILoggedUserService, LoggedUserService>();
services.AddScoped <IErrorOccurrenceRepository, ErrorOccurrenceRepository>();
services.AddScoped <IErrorOccurrenceService, ErrorOccurrenceService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IUserService, UserService>();
services.AddControllers();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(y =>
{
y.TokenValidationParameters.IssuerSigningKey = signingConfiguration.Key;
y.TokenValidationParameters.ValidAudience = token.ValidAudience;
y.TokenValidationParameters.ValidIssuer = token.ValidIssuer;
y.TokenValidationParameters.ValidateIssuerSigningKey = token.ValidadeIssuerSigningKey;
y.TokenValidationParameters.ValidateLifetime = token.ValidateLifetime;
y.TokenValidationParameters.ValidateIssuer = true;
});
services.AddAuthorization(x =>
{
x.AddPolicy(TokenConfiguration.Policy, new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Central de Erros = new Squad(\"#7\", \"Railson Rames\", \"Raphael Fontoura\");",
Version = "v1",
Description = "Hub de registros de errors"
});
x.AddSecurityDefinition("bearer", new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
BearerFormat = "JWT",
In = ParameterLocation.Header,
Scheme = "bearer"
});
x.OperationFilter <AuthenticationRequirementsOperationFilter>();
});
services.AddMvcCore()
.AddAuthorization()
.AddJsonOptions(x =>
{
x.JsonSerializerOptions.IgnoreNullValues = true;
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(x =>
{
x.AddPolicy("EnableCORS", y => { y.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod(); });
});
var token = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(Configuration.GetSection(typeof(TokenConfiguration).Name)).Configure(token);
services.AddSingleton(token);
var signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
services.AddDbContext <ErrorHubContext>();
services.AddControllers();
services.AddHttpContextAccessor();
services.AddSingleton <IAuthenticationService, JwtAuthenticationService>();
services.AddScoped <IErrorOccurrenceRepository, ErrorOccurrenceRepository>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(y =>
{
y.TokenValidationParameters.IssuerSigningKey = signingConfiguration.Key;
y.TokenValidationParameters.ValidAudience = token.ValidAudience;
y.TokenValidationParameters.ValidIssuer = token.ValidIssuer;
y.TokenValidationParameters.ValidateIssuerSigningKey = token.ValidadeIssuerSigningKey;
y.TokenValidationParameters.ValidateLifetime = token.ValidateLifetime;
y.TokenValidationParameters.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(x =>
{
x.AddPolicy(TokenConfiguration.Policy, new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Central de Erros = new Squad(\"#7\", \"Railson Rames\", \"Raphael Fontoura\");",
Version = "v1",
Description = "Hub de registros de errors"
});
x.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Autorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
x.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header
}, new List <string>()
}
});
});
}
protected XadesCommandBase(TOption option, IXadesService xadesService, SigningConfiguration signingConfig) : base(option)
{
_xadesService = xadesService;
_signingConfig = signingConfig;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = _configuration.GetConnectionString("MySQLConnectionString");
if (_environment.IsDevelopment())
{
#region Configuração do migrations do Evolve
try
{
// O cara do vídeo usou o pomelo para conectar ao mysql porque no início do asp.net core não tinha
// um driver para mysql nem da M$ nem da oracle (agora tem mas não suporta asp.net core 2.0).
// Dessa forma, dá erro nesta linha pois o compilador identifica tanto o MySqlConnection, quanto o MySqlConnector do pomelo.
// Com isso, foi acrescentado ao csproj um alias para resolver as referencias usando o MySqlConnector.
// Obs.: isso vai ferrar com as demais referências do projeto...tem que fechar e abrir novamente
// ou mudar para o modo pasta e depois retornar para o modo solution, recarregando o projeto. :-S
var evolveConnection = new MySql.Data.MySqlClient.MySqlConnection(connectionString);
var evolve = new Evolve.Evolve(evolveConnection, msg => _logger.LogInformation(msg))
{
Locations = new[] { "db/migrations" },
IsEraseDisabled = true
};
evolve.Migrate();
}
catch (System.Exception ex)
{
_logger.LogCritical("Database migration failed", ex);
throw ex;
}
#endregion
}
services.AddDbContext <MySQLContext>(options =>
{
options.UseMySql(connectionString);
});
// Configuração mínima, (para adicionar autenticação, precisa colocar depois...)
//services.AddMvcCore().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
// Configuração normal
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_2);
services.AddApiVersioning(options => options.ReportApiVersions = true);
// Register the Swagger generator, defining 1 or more Swagger documents
// Ref.: https://docs.microsoft.com/en-us/aspnet/core/tutorials/getting-started-with-swashbuckle?view=aspnetcore-2.2&tabs=visual-studio
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Title = "RESTful API With ASP.NET Core 2.2",
Version = "v1"
});
});
#region Configuração de autenticação com JWT
//Ref. ok: https://medium.com/@renato.groffe/asp-net-core-2-0-autentica%C3%A7%C3%A3o-em-apis-utilizando-jwt-json-web-tokens-4b1871efd
var signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
_configuration.GetSection("TokenConfigurations"))
.Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfiguration.Key;
paramsValidation.ValidateAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verificação se um token recebido ainda é válido
paramsValidation.ValidateLifetime = true;
// Tempo de tolerância para expiração de um token
// (utilizado caso haja problemas de sincronismo de horário
// entre diferentes computadores envolvidos no processo de comunicação)
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// Ativa o uso do token como forma de autorizar o acesso
// a recursos desse projeto
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new Microsoft.AspNetCore.Authorization.AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.Build());
});
#endregion
RegisterDIContainer(services);
}
// 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 signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
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 = signingConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
//Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
//Valida se um token recebido ainda é valido
paramsValidation.ValidateLifetime = true;
// Tempo de tolerância para a expiração de um token (utilizado
// caso haja problemas de sincronismo de horário entre diferentes
// computadores envolvidos no processo de comunicação)
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
//services.AddMvc(options => { options.EnableEndpointRouting = false; });
services.AddControllers()
.AddNewtonsoftJson();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new OpenApiInfo
{
Title = "Bookings API",
Version = "v1",
Description = "API REST using ASPNETCore 3.0",
Contact = new OpenApiContact
{
Name = "Larissa Heloisa / Carol Araujo",
Url = new Uri("https://github.com/larissa-heloisa")
}
});
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>() }
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigureService.ConfigureDependencyService(services);
ConfigureRepository.ConfigureDependencyRepository(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 signingConfiguration = new SigningConfiguration();
services.AddSingleton(signingConfiguration);
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 = signingConfiguration.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();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Projeto API ASP .NET Core 3.1",
Version = "v1",
Contact = new OpenApiContact
{
Name = "Guilherme Fiola",
Url = new Uri("https://github.com")
}
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
In = ParameterLocation.Header,
Description = "Entre com o token JWT",
Name = "Authorization",
Type = SecuritySchemeType.ApiKey
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
#region configurando swagger
services.AddSwaggerGen(c =>
{
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>()
}
});
});
#endregion
#region configurando token
var signingConfiguration = new SigningConfiguration();
var tokenConfiguration = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfiguration);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidations = bearerOptions.TokenValidationParameters;
paramsValidations.IssuerSigningKey = signingConfiguration.Key;
paramsValidations.ValidateAudience = false;
paramsValidations.ValidateIssuer = false;
paramsValidations.ValidateIssuerSigningKey = true;
paramsValidations.ValidateLifetime = true;
paramsValidations.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(s =>
{
s.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
#endregion
services.AddDbContext <Data.Data.DataContext>(options => options.UseSqlite("Data Source=ChurrasTrinca.db"));
//services.AddScoped<Data.Data.DataContext, Data.Data.DataContext>();
services.AddScoped(typeof(IRepositoryBase <>), typeof(BaseRepository <>));
services.AddScoped <ILoginRepository, LoginRepository>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IChurrasService, ChurrasService>();
services.AddScoped <ILoginService, LoginService>();
services.AddSingleton(tokenConfiguration);
services.AddSingleton(signingConfiguration);
}
public GetStateCommand(GetStateOptions option, IXadesService xadesService, SigningConfiguration signingConfig, GisServiceConfiguration serviceConfig)
: base(option, xadesService, signingConfig, serviceConfig)
{
}
public LoginService(IUserRepository repository, SigningConfiguration signingConfiguration, IConfiguration configuration)
{
_repository = repository;
_signingConfiguration = signingConfiguration;
_configuration = configuration;
}
// 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>(opt => opt.UseMySql(connectionString));
ExecuteMigrations();
var signingConfigurations = new SigningConfiguration();
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.AddControllers();
services.AddApiVersioning();
//Add Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "RestFul Api with Asp net Core", Version = "v1"
});
});
//Incluindo outros content type
services.AddMvc(opt =>
{
opt.RespectBrowserAcceptHeader = true;
opt.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
opt.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json"));
}).AddXmlSerializerFormatters();
//HATEOAS
var filterOptions = new HyperMediaFilterOptions();
filterOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
services.AddSingleton(filterOptions);
services.AddScoped(typeof(IRepository <>), typeof(GenericRepository <>));
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IPersonRepository, PersonRepository>();
services.AddScoped <IPersonBusiness, PersonBusiness>();
services.AddScoped <IBookBusiness, BookBusiness>();
services.AddScoped <ILoginBusiness, LoginBusiness>();
services.AddScoped <IFileBusiness, FileBusiness>();
}
public LoginBusiness(SigningConfiguration signingConfiguration, TokenConfiguration tokenConfiguration, IUserRepository repository)
{
_signingConfigurations = signingConfiguration;
_tokenConfiguration = tokenConfiguration;
_repository = repository;
}
