public TokenConfigurations()
{
Signing = new SigningConfigurations();
}
public Object Autenticar(TUsuario usuario,
[FromServices] SigningConfigurations SigningConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
TUsuario user;
try
{
user = _context.TUsuario.Single(u => u.Email == usuario.Email);
}
catch (InvalidOperationException)
{
user = null;
}
bool credenciaisValidas = false;
if (usuario != null && !String.IsNullOrWhiteSpace(usuario.Email))
{
credenciaisValidas = (user != null &&
user.Senha == usuario.Senha);
}
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(user.Email, "Login"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Email)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = SigningConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new
{
userid = _context.TUsuario.Where(u => u.Email == usuario.Email).First().UserId,
username = _context.TUsuario.Where(u => u.Email == usuario.Email).First().Nome,
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "Ok"
});
}
else
{
return(new
{
authenticated = false,
message = "Falha na autenticação"
});
}
}
public ActionResult <Response <TokenResponseDTO> > Post([FromBody] CredentialsDTO dto,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations,
[FromServices] IMemoryCache cache)
{
if (dto == null ||
(string.IsNullOrWhiteSpace(dto.UserID) && string.IsNullOrWhiteSpace(dto.SecretKey) && string.IsNullOrWhiteSpace(dto.RefreshToken)) ||
(!string.IsNullOrWhiteSpace(dto.UserID) && !string.IsNullOrWhiteSpace(dto.SecretKey) && !string.IsNullOrWhiteSpace(dto.RefreshToken)) ||
(string.IsNullOrWhiteSpace(dto.RefreshToken) && (string.IsNullOrWhiteSpace(dto.UserID) || string.IsNullOrWhiteSpace(dto.SecretKey))) ||
(!string.IsNullOrWhiteSpace(dto.RefreshToken) && (!string.IsNullOrWhiteSpace(dto.UserID) || !string.IsNullOrWhiteSpace(dto.SecretKey)))
)
{
return(BadRequest());
}
var watch = Stopwatch.StartNew();
Response <TokenResponseDTO> result = new Response <TokenResponseDTO>();
try
{
bool isValidCredentials = false;
string cachedUserId = null;
if (string.IsNullOrWhiteSpace(dto.RefreshToken))
{
dto.SecretKey = GetEncode512(dto.SecretKey);
isValidCredentials = _facade.Login(dto);
}
if (isValidCredentials ||
(cache.TryGetValue("refresh_token", out string cachedRefreshToken) && cache.TryGetValue("user_id", out cachedUserId) && cachedRefreshToken == dto.RefreshToken))
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(cachedUserId ?? dto.UserID, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, cachedUserId ?? dto.UserID)
}
);
var now = DateTime.Now;
var cacheExpirate = now + TimeSpan.FromSeconds(tokenConfigurations.Seconds) * 2;
TokenResponseDTO tokenResponse = new TokenResponseDTO()
{
TokenExpirate = tokenConfigurations.Seconds,
RefreshTokenExpirate = tokenConfigurations.Seconds * 2
};
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = now,
Expires = now + TimeSpan.FromSeconds(tokenConfigurations.Seconds)
});
tokenResponse.Token = handler.WriteToken(securityToken);
cache.Remove("refresh_token");
cache.Remove("user_id");
tokenResponse.RefreshToken = SetCache(cache, "refresh_token", Guid.NewGuid().ToString().Replace("-", string.Empty), cacheExpirate);
SetCache(cache, "user_id", cachedUserId ?? dto.UserID, cacheExpirate);
result.Items.Add(tokenResponse);
result.Success = true;
}
else
{
result.AddError(!isValidCredentials ? "Invalid credentials" : "Refresh token is invalid or expired");
}
}
catch (Exception ex)
{
result.AddError(ex);
}
watch.Stop();
result.ResponseTime = watch.Elapsed.TotalSeconds.ToString("0.0### seconds");
result.HttpStatusCode = System.Net.HttpStatusCode.OK;
return(result);
}
public LoginService(LoginRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration)
{
_repository = repository;
_signingConfigurations = signingConfigurations;
_tokenConfiguration = tokenConfiguration;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
// add cors
services.AddCors();
var config = Configuration["AppSettings:Database"];
// Add Context - will be removed in the real implementation
services.AddDbContext <ApplicationDbContext>(options => { options.UseInMemoryDatabase("web.api"); });
// Swagger Config
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new Info {
Title = "Web Api 2.2", Version = "V1"
});
});
// Fluent Validation
services.AddValidators();
// Add Identity
services.AddIdentityConfiguration();
var s = Configuration["Redis:host"];
//Add Redis
services.AddDistributedRedisCache(option =>
{
option.Configuration = Configuration["Redis:host"];
option.InstanceName = Configuration["Redis:db_name"];
});
// appSettings
//var appSettingsSection = Configuration.GetSection("AppSettings");
//services.Configure<AppSettings>(appSettingsSection);
// JWt Guards
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
Configuration.GetSection("TokenConfigurations"))
.Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
var jwt = new Jwt(tokenConfigurations);
services.AddSingleton(jwt);
services.AddJwtSecurity(signingConfigurations, tokenConfigurations);
// Auto Mapper Config
var configMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new DomainProfile());
});
services.AddSingleton(configMapper.CreateMapper());
// DI Injection
services.AddSingleton <IAuthService, AuthService>();
services.AddSingleton <IRepositoryFacade, RepositoryFacade>();
services.AddScoped <CacheControllerAttribute>();
//services.AddAuthentication();
}
public IActionResult Login([FromBody] UsuarioDomain usuario_,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
try
{
UsuarioDomain _usuario = _usuarioRepository.UsuarioExiste(usuario_.Email, usuario_.Password);
if (_usuario != null)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(_usuario.UsuarioId.ToString(), "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, _usuario.UsuarioId.ToString()),
new Claim("Id", _usuario.UsuarioId.ToString()),
new Claim("Nome", _usuario.Perfil.Nome),
});
identity.AddClaim(new Claim(ClaimTypes.Role, _usuario.Role));
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity
});
var token = handler.WriteToken(securityToken);
var retornoUsuario = new {
id = _usuario.UsuarioId,
email = _usuario.Email,
role = _usuario.Role,
ativo = _usuario.Ativo,
perfil = new {
id = _usuario.Perfil.PerfilId,
usuarioId = _usuario.UsuarioId,
nome = _usuario.Perfil.Nome,
miniBio = _usuario.Perfil.MiniBio,
foto = "",
cep = _usuario.Perfil.Cep,
sedeId = _usuario.Perfil.SedeId
}
};
var retorno = new
{
authenticated = true,
accessToken = token,
message = "OK",
usuario = retornoUsuario
};
return(Ok(retorno));
}
return(NotFound("Email ou senha inválido!"));
}
catch (System.Exception e)
{
return(BadRequest(e.Message));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//Injeção de dependencia
ConfigureService.ConfigureDependenciesService(services);
ConfigureRepository.ConfigureDependenciesRepository(services);
//Injeção do automapper
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);
//Token de autenticação
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
//Authentication Bearer Token
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;
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateLifetime = true;
paramsValidation.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
//Controllers MVC
services.AddControllers();
//swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "Api Modelo Asp.Net Core 3.1",
Description = "Arquitetura DDD",
TermsOfService = new Uri("http://www.wmtecnologia.com.br"),
Contact = new OpenApiContact
{
Name = "Willian Marcel Borges",
Email = "*****@*****.**",
Url = new Uri("http://www.wmtecnologia.com.br")
},
License = new OpenApiLicense
{
Name = "Termos de Licensa de Uso",
Url = new Uri("http://www.wmtecnologia.com.br")
}
});
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)
{
services.AddDistributedRedisCache(options =>
{
options.Configuration =
Configuration.GetConnectionString("ConexaoRedis");
options.InstanceName = "APIFCPark";
});
services.AddDbContext <IdentityDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("BaseIdentity")));
services.AddDbContext <FCParkDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("App")));
services.AddScoped <IUnitOfWork, UnitOfWork>();
services.AddTransient <IVeiculoService, VeiculoService>();
services.AddTransient <IEstabelecimentoService, EstabelecimentoService>();
services.AddTransient <IMovimentacaoVeiculoService, MovimentacaoVeiculoService>();
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <IdentityDbContext>()
.AddDefaultTokenProviders();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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.AddCors();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo {
Title = "API FC PARK",
Version = "v1",
Description = "REST API de estacionamento para demonstrativo de aplicação .NET CORE",
Contact = new OpenApiContact {
Name = "Vinícius Espuri Barboza", Email = "*****@*****.**"
},
License = new OpenApiLicense {
Name = "OPEN REST API FC PARK"
}
});
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Authorization",
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer",
BearerFormat = "JWT",
In = ParameterLocation.Header,
Description = "JWT Authorization header using the Bearer scheme."
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new string[] {}
}
});
});
services.AddScoped <AccessManager>();
services.AddControllers().AddXmlSerializerFormatters();
services.AddAutoMapper(typeof(Startup));
}
public static IServiceCollection AddAuthJwtConfigurations(this IServiceCollection services, SigningConfigurations signingConfigurations, TokenConfigurations 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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
paramsValidation.ValidateLifetime = true;
// Tempo de tolerância para a expiração de um token
paramsValidation.ClockSkew = TimeSpan.Zero;
});
// 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());
});
return(services);
}
public UserServiceImpl(IUserRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration)
{
_repository = repository;
_signingConfigurations = signingConfigurations;
_tokenConfiguration = tokenConfiguration;
}
public object Post(
[FromBody] UserViewModel usuario,
[FromServices] UserManager <ApplicationUser> userManager,
[FromServices] SignInManager <ApplicationUser> signInManager,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
ApplicationUser userIdentity = new ApplicationUser();
if (usuario == null && string.IsNullOrWhiteSpace(usuario.UserID))
{
LoginResponse response = new LoginResponse
{
Authenticated = false,
Message = "Falha ao autenticar"
};
return(response);
}
// Verifica a existência do usuário nas tabelas do
// ASP.NET Core Identity
userIdentity = userManager.FindByNameAsync(usuario.UserID).Result;
if (userIdentity != null)
{
// Efetua o login com base no Id do usuário e sua senha
var resultadoLogin = signInManager
.CheckPasswordSignInAsync(userIdentity, usuario.Password, false)
.Result;
if (resultadoLogin.Succeeded)
{
// Verifica se o usuário em questão possui a role de Acesso
credenciaisValidas = userManager.IsInRoleAsync(userIdentity, Roles.ROLE_API).Result;
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new[] {
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID),
new Claim("userName", usuario.UserID.ToUpper()),
new Claim("userGuid", userIdentity.Id),
new Claim("RememberMe", usuario.RememberMe.ToString()),
new Claim("Dominio", usuario.Dominio)
}
, CookieAuthenticationDefaults.AuthenticationScheme);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var jwtSecurityToken = handler.CreateJwtSecurityToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
EncryptingCredentials = signingConfigurations.EncryptingCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(jwtSecurityToken);
LoginResponse response = new LoginResponse
{
Authenticated = true,
Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
AccessToken = token,
Message = "OK"
};
return(response);
}
else
{
LoginResponse response = new LoginResponse
{
Authenticated = false,
Message = "Falha ao autenticar"
};
return(response);
}
}
else
{
LoginResponse response = new LoginResponse
{
Authenticated = false,
Message = "Erro ao autenticar. Usuário ou senha inválidos!"
};
return(response);
}
}
else
{
LoginResponse response = new LoginResponse
{
Authenticated = false,
Message = "Erro ao autenticar. Usuário ou senha inválidos!"
};
return(response);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfigureService.ConfigureDependeniesService(services);
ConfigureRepository.ConfigureDependeniesRepository(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 signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfiguration = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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 = signingConfigurations.SecurityKey;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
paramsValidation.ValidateIssuerSigningKey = true;
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
{
Version = "v1",
Title = "AspnetCore 3.1",
Description = "Exemplo de API REST criada com o Asp.Net core e arquitetura DDD",
TermsOfService = new Uri("https://example.com/terms"),
Contact = new OpenApiContact
{
Name = "Ivan Barros",
Email = "*****@*****.**",
Url = new Uri("https://twitter.com/spboyer"),
},
License = new OpenApiLicense
{
Name = "Use under LICX",
Url = new Uri("https://example.com/license"),
}
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme {
In = ParameterLocation.Header,
Description = "Entre com o token JWT",
Name = "authorization",
Type = SecuritySchemeType.ApiKey
});
// Swagger 2.+ support
c.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference {
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>()
}
});
});
services.AddControllers().AddNewtonsoftJson();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
_logger.LogInformation("Adding services...");
services.AddSingleton <IPasswordHasher, PasswordHasher>();
services.AddSingleton <ITokenHandler, Core.TokenHandler>();
services.AddScoped <IAuthenticationService, AuthenticationService>();
services.Configure <StripeSettings>(Configuration.GetSection("Stripe"));
services.Configure <AppOptions>(Configuration.GetSection("app"));
services.Configure <TokenOptions>(Configuration.GetSection("TokenOptions"));
services.Configure <EmailSettings>(Configuration.GetSection("EmailSettings"));
var tokenOptions = Configuration.GetSection("TokenOptions").Get <TokenOptions>();
// Add services that will be used for CRUD operations
services.AddCustomServices();
services.AddAutoMapper(typeof(Startup).Assembly);
services.AddResponseCaching();
var connectionString = Configuration.GetConnectionString("TuringBackendDB");
services.AddDbContext <TuringBackendContext>(c => c.UseMySql(connectionString));
services.AddCors(o => o.AddPolicy("DefaultPolicy", builder => { builder.AllowAnyOrigin(); }));
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new Info
{
Title = "Turing ECommerce API",
Version = "1.2.9",
Description = "Official documentation about Turing ECommerce API"
});
//Locate the XML file being generated by ASP.NET...
var xmlFile = $"{Path.GetFileName(Assembly.GetExecutingAssembly().GetName().Name)}.xml";
//... and tell Swagger to use those XML comments.
c.IncludeXmlComments(xmlFile.ToLower());
c.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"user-key: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[] { } }
};
c.AddSecurityRequirement(security);
});
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
services.AddScoped <IAuthenticationService, AuthenticationService>();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(jwtBearerOptions =>
{
jwtBearerOptions.SaveToken = true;
jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = tokenOptions.Issuer,
ValidAudience = tokenOptions.Audience,
IssuerSigningKey = signingConfigurations.Key,
ClockSkew = TimeSpan.Zero
};
});
services.AddMvc(options =>
{
options.OutputFormatters.Clear();
options.OutputFormatters.Add(new JsonOutputFormatter(new JsonSerializerSettings(),
ArrayPool <char> .Shared));
})
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options => {
options.RespectBrowserAcceptHeader = true; // permite que a Api aceite o tipo de formato enviado pelo client no header da requisição
options.ReturnHttpNotAcceptable = true; // especifica que a Api retornará 406 Not Acceptable caso o client passe no header um formato não suportado
options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml"));
options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json"));
options.FormatterMappings.SetMediaTypeMappingForFormat("csv", MediaTypeHeaderValue.Parse("text/csv"));
}).AddXmlSerializerFormatters().AddCsvSerializerFormatters();
services.AddDbContext <Context>(options => options.UseMySQL(Configuration.GetConnectionString("ConDb")));
services.AddApiVersioning();
var filterOptions = new HyperMediaFilterOptions();
filterOptions.ObjectContentResponseEnricherList.Add(new PersonEricher());
services.AddSingleton(filterOptions);
// DEPENDECY INJECTION
services.AddScoped(typeof(IRepository <>), typeof(Repository <>));
services.AddScoped <IPersonRepository, PersonRepository>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <PersonBusiness>();
services.AddScoped <IBusiness <BookVO>, BookBusiness>();
services.AddScoped <ILoginBusiness, LoginBusiness>();
services.AddScoped <PersonConverter>();
services.AddScoped <BookConverter>();
services.AddRouting();
// DOCUMENTATION
services.AddSwaggerGen(x => {
x.SwaggerDoc("v1", new Info {
Title = "RESTful API with ASP.NET Core", Version = "v1"
});
x.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
});
services.AddCors();
// SECURITY
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
var paramsValidation = options.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(options =>
{
options.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
}
public async Task <object> Post(
[FromBody] UserDto usuario,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
if (usuario != null && !string.IsNullOrEmpty(usuario.UserID))
{
var usuarioBase = await _userService.GetUser(usuario.UserID);
credenciaisValidas = (usuarioBase != null && usuario.UserID == usuarioBase.UserID &&
usuario.AccessKey == usuarioBase.AccessKey);
}
if (credenciaisValidas)
{
var identity = new ClaimsIdentity(
new GenericIdentity(usuario.UserID, "Login"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID)
}
);
var dataCriacao = DateTime.Now;
var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
var retorno = new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
};
return(Task.FromResult(retorno).Result);
}
else
{
var retorno = new
{
authenticated = false,
message = "Falha ao autenticar"
};
return(Task.FromResult(retorno).Result);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
if (_enviroment.IsEnvironment("Test"))
{
Environment.SetEnvironmentVariable("AUTH_AUDIENCE", "ExempleAudience");
Environment.SetEnvironmentVariable("AUTH_ISSUER", "ExempleIssuer");
Environment.SetEnvironmentVariable("AUTH_DURATION", "28800");
}
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 signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
services.AddAuthentication(authOptions =>
{
authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearerOptions =>
{
var paramsValidation = bearerOptions.TokenValidationParameters;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
paramsValidation.ValidAudience = Environment.GetEnvironmentVariable("AUTH_AUDIENCE");
paramsValidation.ValidIssuer = Environment.GetEnvironmentVariable("AUTH_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(s =>
{
s.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "Insert JWT Token",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
s.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference {
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>()
}
});
});
}
public async Task <ActionResult <ResultResponse <LoginResponse> > > Login(
[FromBody] UserModel usuario,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
Stopwatch _stopwatch = Stopwatch.StartNew();
var response = new ResultResponse <LoginResponse>();
response.QueryId = HttpContext.TraceIdentifier;
try
{
ApplicationUser user;
LoginResponse loginResponse = new LoginResponse();
if (usuario != null && !string.IsNullOrWhiteSpace(usuario.Email))
{
// Retrieve User
user = await _userManager.FindByEmailAsync(usuario.Email);
// Login User
if (user != null)
{
loginResponse.Authenticated = _signInManager.CheckPasswordSignInAsync(user, usuario.Password, false).Result.Succeeded;
}
else
{
throw new BusinessException("Email informado não cadastrado no sistema.");
}
if (loginResponse.Authenticated)
{
ClaimsIdentity identity = new ClaimsIdentity(
new ClaimsIdentity(new GenericIdentity(usuario.Email, "Login")),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Email),
}
);
var roles = await _userManager.GetRolesAsync(user);
foreach (var role in roles)
{
identity.AddClaim(new Claim("roles", role));
}
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
loginResponse.AccessToken = handler.WriteToken(securityToken);
loginResponse.Created = dataCriacao.ToString("dd-MM-yyyy HH:mm:ss");
loginResponse.Expiration = dataExpiracao.ToString("dd-MM-yyyy HH:mm:ss");
Console.WriteLine($"[{DateTime.Now} | Login] - Usuário autenticado. " + user.UserName + " : " + loginResponse.AccessToken);
response.Result = loginResponse;
response.Status = new ResultStatus()
{
Code = 200, Message = "Ok"
};
response.ElapsedMilliseconds = _stopwatch.ElapsedMilliseconds;
_stopwatch.Stop();
return(Ok(response));
}
else
{
throw new BusinessException("Usuário ou senha incorretos.");
}
}
else
{
throw new BusinessException("Dados obrigatórios não informados. Verifique sua requisição e tente novamente.");
}
}
catch (BusinessException ex)
{
Console.WriteLine($"[{DateTime.Now} | Login] - Falha no login: "******"[{DateTime.Now} | Login] - Falha no login: "******"Erro ao autenticar."
};
return(Ok(response));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
MongoDbContext.ConnectionString = Configuration.GetSection("MongoConnection:ConnectionString").Value;
MongoDbContext.DatabaseName = Configuration.GetSection("MongoConnection:Database").Value;
MongoDbContext.IsSSL = Convert.ToBoolean(this.Configuration.GetSection("MongoConnection:IsSSL").Value);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddTransient <UsuarioJWTDAO>();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "API QueroCento", Version = "v1"
});
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[] { } },
};
c.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
c.AddSecurityRequirement(security);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Environment.GetEnvironmentVariable("DB_CONNECTION_STRING");
services.AddDbContext <UserContext>(options =>
options.UseNpgsql(
connectionString
)
);
services.AddCors();
services.AddSwaggerGen(options =>
{
options.DescribeAllEnumsAsStrings();
options.SwaggerDoc("v1", new Info
{
Title = "Identity Api",
Version = "v1"
});
// Defina o caminho dos comentários para o Swagger.
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
options.IncludeXmlComments(xmlPath);
});
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
// 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.AddCors();
services.AddDbContext <ReservaContext>(
options => options.UseSqlServer(Configuration.GetConnectionString("CnnStr")));
services.AddScoped <ReservaContext, ReservaContext>();
services.AddScoped <ReservaStoreContext, ReservaStoreContext>();
services.AddTransient <IUow, Uow>();
services.AddScoped <TokenConfigurations, TokenConfigurations>();
services.AddScoped <SigningConfigurations, SigningConfigurations>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <AuthenticatedUser>();
//Service
services.AddTransient <IUsuarioService, UsuarioService>();
services.AddTransient <IFilialService, FilialService>();
services.AddTransient <ISalaService, SalaService>();
services.AddTransient <IReservaService, ReservaService>();
//Repository
services.AddTransient <IUsuarioRepository, UsuarioRepository>();
services.AddTransient <IFilialRepository, FilialRepository>();
services.AddTransient <ISalaRepository, SalaRepository>();
services.AddTransient <IReservaRepository, ReservaRepository>();
//Hadler
services.AddTransient <UsuarioHandler, UsuarioHandler>();
services.AddTransient <FilialHandler, FilialHandler>();
services.AddTransient <SalaHandler, SalaHandler>();
services.AddTransient <ReservaHandler, ReservaHandler>();
//Configurando Token
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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());
});
}
// 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));
ExecuteMigration(connectionString);
//Inicio da execução de login
var signigConfiguration = new SigningConfigurations();
services.AddSingleton(signigConfiguration);
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 = signigConfiguration.Key;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidAudience = 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()
);
});
//Fim da execução de login
services.AddMvc(options =>
{
options.RespectBrowserAcceptHeader = true;
options.FormatterMappings.SetMediaTypeMappingForFormat("xml",
MediaTypeHeaderValue.Parse("text/xml"));
options.FormatterMappings.SetMediaTypeMappingForFormat("json",
MediaTypeHeaderValue.Parse("application/json"));
})
.AddXmlSerializerFormatters();
var filtertOptions = new HyperMediaFilterOptions();
filtertOptions.ObjectContentResponseEnricherList.Add(new BookEnricher());
filtertOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher());
services.AddSingleton(filtertOptions);
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"
});
});
services.AddScoped <IPersonBusiness, PersonBusinessImpl>();
services.AddScoped <IBookBusiness, BookBusinessImpl>();
services.AddScoped <ILoginBusiness, LoginBusinessImpl>();
services.AddScoped <IFileBusiness, FileBusinessImpl>();
services.AddScoped <IUserRepository, UserRepositoryImpl>();
services.AddScoped <IPersonRepository, PersonRepositoryImpl>();
services.AddScoped <IBookRepository, BookRepositoryImpl>();
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)
{
services.AddDbContext <Context>(op => op.UseMySQL(Configuration.GetConnectionString("Atena"))
.UseLoggerFactory(loggerFactory)
.EnableSensitiveDataLogging()
.EnableDetailedErrors());
//services.AddDbContext<Context>(op => op.UseSqlServer(Configuration.GetConnectionString("Atena_SqlServer"))
//.LogTo(Console.WriteLine, LogLevel.Information)
// .EnableSensitiveDataLogging()
// .EnableDetailedErrors());
services = InjecaoDependencia(services);
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
Configuration.GetSection("TokenConfigurations"))
.Configure(tokenConfigurations);
services.AddSingleton(tokenConfigurations);
services.AddCors(options =>
{
options.AddPolicy(name: MyAllowSpecificOrigins,
builder =>
{
builder.WithOrigins("http://localhost:4200",
"https://localhost:4200",
"https://localhost:5001",
"https://bardochiquinho.acmesistemas.com.br",
"http://atena.acmesistemas.com.br")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
paramsValidation.ValidateLifetime = true;
paramsValidation.SaveSigninToken = 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.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddControllers()
.AddJsonOptions(x => x.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles)
.AddOData((opt, srv) =>
{
opt.AddRouteComponents(GetEdmModel()).Filter()
.Count()
.Expand()
.OrderBy()
.SkipToken()
.EnableQueryFeatures()
.Select();
srv.CreateScope();
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Atena", Version = "v1"
});
c.AddSecurityDefinition(
"Bearer",
new OpenApiSecurityScheme
{
Name = "Authorization",
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer",
BearerFormat = "JWT",
In = ParameterLocation.Header,
Description = "Please enter JWT with Bearer into field"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
});
}
public object Post(
[FromBody] User usuario,
[FromServices] UserManager <ApplicationUser> userManager,
[FromServices] SignInManager <ApplicationUser> signInManager,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
if (usuario != null && !String.IsNullOrWhiteSpace(usuario.UserID))
{
// Verifica a existência do usuário nas tabelas do
// ASP.NET Core Identity
var userIdentity = userManager
.FindByNameAsync(usuario.UserID).Result;
if (userIdentity != null)
{
// Efetua o login com base no Id do usuário e sua senha
var resultadoLogin = signInManager
.CheckPasswordSignInAsync(userIdentity, usuario.Password, false)
.Result;
if (resultadoLogin.Succeeded)
{
// Verifica se o usuário em questão possui
// a role Acesso-APIAlturas
credenciaisValidas = userManager.IsInRoleAsync(
userIdentity, Roles.ROLE_API_ALTURAS).Result;
}
}
}
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.UserID, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
});
}
else
{
return(new
{
authenticated = false,
message = "Falha ao autenticar"
});
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationContext>(options =>
{
options
.UseLazyLoadingProxies()
.EnableSensitiveDataLogging()
.UseNpgsql(Environment.GetEnvironmentVariable("DATABASE_URL").ToConnectionString() ?? Configuration.GetConnectionString("Default"));
});
services.AddCors(options =>
{
options.AddDefaultPolicy(
builder =>
{
builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod();
});
});
services
.AddIdentity <User, IdentityRole <long> >(options =>
{
options.Password.RequireDigit = true;
options.Password.RequiredLength = 6;
options.Password.RequiredUniqueChars = 0;
options.Password.RequireLowercase = true;
options.Password.RequireUppercase = false;
options.Password.RequireNonAlphanumeric = false;
})
.AddEntityFrameworkStores <ApplicationContext>()
.AddDefaultTokenProviders();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfiguration = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
Configuration.GetSection(nameof(TokenConfigurations))
).Configure(tokenConfiguration);
services.AddSingleton(tokenConfiguration);
services.AddScoped <ILifeService, LifeService>();
services.AddScoped <IFeedbackService, FeedbackService>();
services.AddScoped <IProgressStepsLifeService, ProgressStepsLifeService>();
services.AddAutoMapper(GetType().Assembly);
services.AddAuthentication().AddJwtBearer("Bearer", options =>
{
var paramsValidation = options.TokenValidationParameters;
paramsValidation.ValidateAudience = true;
paramsValidation.ValidAudience = tokenConfiguration.Audience;
paramsValidation.ValidateIssuerSigningKey = true;
paramsValidation.ValidateIssuer = true;
paramsValidation.ValidIssuer = tokenConfiguration.Issuer;
paramsValidation.ValidateLifetime = true;
paramsValidation.ClockSkew = TimeSpan.Zero;
paramsValidation.IssuerSigningKey = signingConfigurations.Key;
});
services.AddAuthorization(options =>
{
options.AddPolicy(
"Bearer",
new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.Build()
);
});
services.AddControllers();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//habilita cors para comunicação com ionic
services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
{
builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
}));
//inicializando o entity framework, definindo ele como uma serviço
services.AddDbContext <CadastroContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("ConexaoDbCadastro")));
services.AddTransient <User>();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfiguration();
new ConfigureFromConfigurationOptions <TokenConfiguration>(
Configuration.GetSection("ConfiguracaoToken"))
.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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
services.AddSingleton(Configuration.GetSection("ConfiguracaoToken").Get <TokenConfiguration>());
// services.Configure<ConfiguracaoToken>(Configuration.GetSection("ConfiguracaoToken"));
services.AddMvc();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
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 signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "WebApi AspNetCore",
Description = "Arquitetura DDD",
TermsOfService = new Uri("http://www.google.com.br"),
Contact = new OpenApiContact
{
Name = "Nome",
Email = "*****@*****.**",
Url = new Uri("http://www.google.com.br")
},
License = new OpenApiLicense
{
Name = "Termo de Licença de Uso",
Url = new Uri("http://www.google.com.br")
}
});
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)
{
//services.AddSingleton<DaniQuizContext>();
//var connection = @"Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=aspnet-MvcMovie-fefdc1f0-bd81-4ce9-b712-93a062e01031;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|\aspnet-MvcMovie-fefdc1f0-bd81-4ce9-b712-93a062e01031.mdf";
//services.AddDbContext<DaniQuizContext>
// (options => options.UseSqlServer(connection));
services.AddDbContext <DaniQuizContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped <IAppUsuarioLogin, AppUsuarioLogin>();
services.AddScoped <IAppCadastrar, AppCadastrar>();
services.AddScoped <IAppEnquete, AppEnquete>();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
services.AddCors();
services.AddMvc();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
services.AddMvc();
// Configure Identity
string connectionString = "Data Source=200.98.165.60;UID=sa;PWD=29800f8ce4ea41d2b2b2cee8f71f5d02";
services.AddDbContext <IdentityDbContext>(options =>
options.UseSqlServer(connectionString, providerOptions => providerOptions.CommandTimeout(60).MigrationsAssembly("Identity.API")));
services.AddIdentity <IdentityUser, IdentityRole>()
.AddEntityFrameworkStores <IdentityDbContext>()
.AddDefaultTokenProviders();
services.Configure <IdentityOptions>(options => {
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireLowercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
});
services.Configure <IdentityOptions>(options => {
options.SignIn.RequireConfirmedEmail = true;
});
// Messages
services.AddTransient <IMessageService, EmailMessageService>();
// Security
services.AddTransient <ITokenGenerator, TokenGenerator>();
var signingConfigurations = new SigningConfigurations();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurations();
new ConfigureFromConfigurationOptions <TokenConfigurations>(
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;
// Valida a assinatura de um token recebido
paramsValidation.ValidateIssuerSigningKey = true;
// Verifica se um token recebido ainda é válido
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;
});
// 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());
});
}
public LoginBusinessImpl(IWebUserRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration)
{
_repository = repository;
_signingConfigurations = signingConfigurations;
_tokenConfigurations = tokenConfiguration;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Injeção de Dependência
ConfigureRepository.ConfigureDependenceRepository(services);
ConfigureService.ConfigureDependenceInjection(services);
var config = new AutoMapper.MapperConfiguration(cfg =>
{
cfg.AddProfile(new DtoToModelProfile());
cfg.AddProfile(new EntitiToDtoProfile());
cfg.AddProfile(new ModelToEntityProfile());
});
IMapper mapper = config.CreateMapper();
services.AddSingleton(mapper);
var signingConfiguration = new SigningConfigurations();
services.AddSingleton(signingConfiguration);
// Authentication
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("Admin", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.RequireRole("Admin").Build());
auth.AddPolicy("UserAdmin", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.RequireRole("UserAdmin", "Admin").Build());
auth.AddPolicy("User", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.RequireRole("UserAdmin", "Admin", "User").Build());
});
// Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Title = "SRJ - Serviço de Doações",
Version = "1.0.0",
Description = "SRJ Micro Services Version 1.0.0 ",
Contact = new Microsoft.OpenApi.Models.OpenApiContact
{
Name = "SRJ Soluções",
Email = "*****@*****.**"
}
});
c.AddSecurityDefinition("User", 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 = "User"
}
}, new List <string>()
}
});
});
// Instalar no IIS
services.Configure <IISOptions>(o =>
{
o.ForwardClientCertificate = false;
});
services.AddCors(options =>
{
options.AddPolicy(MyAllowSpecificOrigins, builder => builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
//.SetIsOriginAllowed(origin => true)
//.AllowCredentials()
);
});
services.AddControllers()
.AddNewtonsoftJson();
}
