public async Task <IActionResult> Registrar(RegistroViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("Registro", viewModel));
}
var res = await _usuarioService.Registro(viewModel);
if (!res.Succeeded)
{
res.Errors.ToList().ForEach(e => ModelState.AddModelError("Identity", e.Description));
return(View("Registro"));
}
if (res != null && res.Succeeded)
{
var loginUsuarioViewModel = new LoginUsuarioViewModel();
loginUsuarioViewModel.Email = viewModel.Email;
loginUsuarioViewModel.Senha = viewModel.Senha;
var user = await _usuarioService.Login(loginUsuarioViewModel);
if (user == true)
{
return(RedirectToAction("IndexUsuario", "Home"));
}
}
return(View("Registro"));
}
public async Task <ActionResult> Login(LoginUsuarioViewModel loginUser)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var usuarioIdentity = await _userManager.FindByEmailAsync(loginUser.Email);
var result = await _signInManager.PasswordSignInAsync(usuarioIdentity.UserName, loginUser.Senha, false, true);
if (result.Succeeded)
{
return(CustomResponse(await GerarJwt(loginUser.Email)));
}
if (result.IsLockedOut)
{
NotificarErro("Usuário temporariamente bloqueado por tentativas inválidas");
return(CustomResponse(loginUser));
}
NotificarErro("Usuário ou Senha incorretos");
return(CustomResponse(loginUser));
}
public async Task <IActionResult> Login(LoginUsuarioViewModel model)
{
if (ModelState.IsValid)
{
var result = await _auth.PostLoginAsync(model);
if (!string.IsNullOrEmpty(result.Data.AccessToken))
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, model.Email),
new Claim("Token", result.Data.AccessToken)
}.Concat(result.Data.UserToken.Claims.Select(c => new Claim(c.Type, c.Value)));
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal);
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "Erro na autenticação");
return(View(model));
}
return(View(model));
}
public IActionResult POST([FromBody] LoginUsuarioViewModel model, [FromServices] IUsuarioRepository usuarioRepository, [FromServices] ICriptografia criptografia)
{
if (ModelState.IsValid)
{
try
{
var usuario = usuarioRepository.Get(model.Login, criptografia.GETMD5(model.Senha));
if (usuario != null)
{
//TODO
return(Ok());
}
else
{
return(StatusCode(400, "Acesso negado. O Login ou Senha incorreto"));
}
}
catch (Exception erro)
{
return(StatusCode(500, erro.Message));
}
}
else
{
return(StatusCode(400, ModelStateValidation.GetErrors(ModelState)));
}
}
public async Task <IActionResult> LoginUsuario(LoginUsuarioViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var result =
await
signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe,
lockoutOnFailure : false);
if (result.Succeeded)
{
return(RedirectToLocal(returnUrl));
}
if (result.RequiresTwoFactor)
{
//
}
if (result.IsLockedOut)
{
return(View("Lockout"));
}
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View(model));
}
return(View(model));
}
public async Task <LoginRespostaViewModel> PostLoginAsync(LoginUsuarioViewModel model)
{
var usuario = JsonSerializer.Serialize(model, JsonSerializerOptions);
var conteudo = new StringContent(usuario, Encoding.UTF8, "application/json");
var resposta = await _httpClient.PostAsync("login", conteudo);
var json = await resposta.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <LoginRespostaViewModel>(json, JsonSerializerOptions));
}
private Usuario autenticarUsuario(LoginUsuarioViewModel login)
{
var hashSenha = new HashSenha(SHA256.Create());
var senhaHasheada = hashSenha.HasheandoSenha(login.Senha);
var usuario = context.Usuario
.FirstOrDefault(us => (us.LoginUsuario == login.LoginUsuario && us.Senha == senhaHasheada) ||
(us.Email == login.Email && us.Senha == senhaHasheada));
return(usuario);
}
public async Task <IActionResult> Post([FromBody] LoginUsuarioViewModel viewModel)
{
var loginResultado = await _usuarioService.Login(viewModel);
if (!loginResultado)
{
AdicionarErroModelState("Email ou senha incorretos");
return(Resposta());
}
var usuario = await _userManager.FindByEmailAsync(viewModel.Email);
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")));
claims.Add(new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Id));
claims.Add(new Claim("UsuarioId", usuario.Id));
GenericIdentity genericIdentity = new GenericIdentity(usuario.Email, "Login");
ClaimsIdentity identity = new ClaimsIdentity(genericIdentity, claims);
DateTime dtCreation = DateTime.Now;
DateTime dtExpiration = dtCreation.AddSeconds(_tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityTokenDescriptor = new SecurityTokenDescriptor
{
Issuer = _tokenConfigurations.Issuer,
Audience = _tokenConfigurations.Audience,
SigningCredentials = _signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dtCreation,
Expires = dtExpiration
};
var securityToken = handler.CreateToken(securityTokenDescriptor);
var token = handler.WriteToken(securityToken);
return(Resposta(new
{
email = usuario.Email,
usuarioId = usuario.Id,
created = dtCreation.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dtExpiration.ToString("yyyy- MM-dd HH:mm:ss"),
accessToken = token,
}));
}
public ActionResult Login(LoginUsuarioViewModel model)
{
var usuario = _serviceUsuarios.BuscarPorLogin(model.Login);
if (usuario != null && usuario.Senha.Equals(model.Senha) && usuario.Login.Equals(model.Login))
{
AplicacaoWeb.LogarUsuario(usuario);
return(RedirectToAction("Index"));
}
else
{
ViewBag.Erros = "Usuario ou senha Inválido!";
return(View("~/Views/Shared/_Login.cshtml"));
}
}
public IActionResult Login(LoginUsuarioViewModel login)
{
IActionResult response = Unauthorized();
var usuario = autenticarUsuario(login);
if (usuario != null)
{
if (usuario.StatusAprovacao == "Aprovado")
{
var tokenString = gerarJsonWebToken(usuario);
response = Ok(new { token = tokenString });
}
}
return(response);
}
public async Task <IActionResult> Entrar([FromBody] LoginUsuarioViewModel user)
{
if (ModelState.IsValid)
{
var result = await usuarioService.LoginUsuarioAsync(user);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
return(BadRequest());
}
public IActionResult Login(LoginUsuarioViewModel usuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(a => a.Errors).Select(a => a.ErrorMessage)));
}
var user = _context.Users.FirstOrDefault(a => a.Email.Contains(usuario.Email) && a.Senha == usuario.Senha);
if (user != null)
{
return(Ok(GerarJwt(user.Email)));
}
return(BadRequest(new[] { "Usuário ou senha inválido" }));
}
public async void Usuario_RealizarLogin_DeveExecutarComSucesso()
{
// Arrange
var obj = new LoginUsuarioViewModel
{
//Email = _testsFixture.UsuarioEmail,
//Senha = _testsFixture.UsuarioSenha
Email = "*****@*****.**",
Senha = "Teste@123",
};
string strData = JsonConvert.SerializeObject(obj);
var contentData = new StringContent(strData, Encoding.UTF8, "application/json");
// Act
var postResponse = await _testsFixture.Client.PostAsync("/api/identidade/autenticar", contentData);
// Assert
Assert.Equal(HttpStatusCode.OK, postResponse.StatusCode);
}
public async Task <ActionResult> Login(LoginUsuarioViewModel loginUsuario)
{
if (!ModelState.IsValid)
{
return(Retorno(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(loginUsuario.Email, loginUsuario.Password, false, true);
if (result.Succeeded)
{
return(Retorno(await GerarToken(loginUsuario.Email)));
}
if (result.IsLockedOut)
{
NotificarErro("Usuário bloqueado por execeder número máximo de tentativas de login");
return(Retorno(loginUsuario));
}
NotificarErro("Usuário ou senha incorretos.");
return(Retorno(loginUsuario));
}
public async Task <IActionResult> EnviarLogin(LoginUsuarioViewModel viewModel, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View("Login", viewModel));
}
var res = await _usuarioService.Login(viewModel);
if (res == true)
{
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
return(RedirectToAction("IndexUsuario", "Home"));
}
else
{
ModelState.AddModelError("Login", "Email ou Senha incorretos");
return(View("Login"));
}
}
public async Task <ActionResult> Login(LoginUsuarioViewModel login)
{
if (!ModelState.IsValid)
{
return(Result(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(login.Login, login.Senha, false, true);
if (result.Succeeded)
{
return(Result(GerarJwtToken()));
}
if (result.IsLockedOut)
{
NotificarErro("Usuario temporariamente bloqueado por tentativas invalidas!");
return(Result(login));
}
NotificarErro("Usuario e senha invalidos!");
return(Result(login));
}
public ActionResult Index(LoginUsuarioViewModel usuarioViewModel)
{
if (ModelState.IsValid)
{
var usuario = _usuarioRepository
.Autenticar(usuarioViewModel.Email, usuarioViewModel.Senha);
if (usuario != null)
{
usuarioViewModel = Mapper.Map <Usuario, LoginUsuarioViewModel>(usuario);
Session["usuario"] = usuarioViewModel;
return(RedirectToAction("Index", "Home", new { area = "administracao" }));
}
else
{
TempData["MsgFalhaLogin"] = @"Dados incorretos.
Por favor, verifique seus
dados e tente novamente.";
}
}
return(View(usuarioViewModel));
}
public async Task <IActionResult> LogIn([FromBody] LoginUsuarioViewModel logInViewModel)
{
// Valida los datos de acceso.
if (string.IsNullOrEmpty(logInViewModel.Usuario) || string.IsNullOrEmpty(logInViewModel.Password))
{
return(this.BadResponse("Es necesario llenar todos los campos"));
}
var user = await _usrMngr.FindByNameAsync(logInViewModel.Usuario);
if (user == null)
{
return(this.BadResponse("No se encontro al usuario"));
}
var passwordCheck = await _usrMngr.CheckPasswordAsync(user, logInViewModel.Password);
if (!passwordCheck)
{
return(this.BadResponse("La contraseña no coincide."));
}
var identity = await GetClaimsIdentity(logInViewModel.Usuario, logInViewModel.Password);
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, logInViewModel.Usuario, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(this.OkResponse(new SessionModel
{
UserId = user.Id.ToString(),
Email = user.Email,
ExpiresIn = jwt.ExpiresIn,
JwtToken = jwt.Auth_Token,
Role = user.Role
}));
}
public async Task <ActionResult> Login(LoginUsuarioViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await _signInService.PasswordSignInAsync(model.Usuario, model.Password, false, false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToAction("Index", "Home", new { Area = "" }));
case SignInStatus.LockedOut:
case SignInStatus.RequiresVerification:
case SignInStatus.Failure:
default:
AddMessage("Error de login, vuelva a comprobar sus datos", Infraestructura.Managers.Imp.MessageType.Error);
return(View(model));
}
}
public async Task <RespostaViewModel> LoginUsuarioAsync(LoginUsuarioViewModel user)
{
var usuarioEncotrado = await userManager.FindByEmailAsync(user.Email);
if (usuarioEncotrado == null)
{
return(new RespostaViewModel
{
Mensagem = "Não foi possível logar, verifique seu email e senha.",
Objeto = null,
Success = false
});
}
var result = await userManager.CheckPasswordAsync(usuarioEncotrado, user.Password);
if (!result)
{
return(new RespostaViewModel
{
Mensagem = "Verifique os dados informados. Senha ou email estão incorretos.",
Objeto = null,
Success = false
});
}
// Gerar os tokens, com os direitos que o usuário tem
var claims = new[]
{
new Claim("Email", user.Email),
new Claim(ClaimTypes.NameIdentifier, usuarioEncotrado.Id)
};
// Configuração do token
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["AuthSettings:Key"]));
var token = new JwtSecurityToken(
issuer: configuration["AuthSettings:Issuer"],
audience: configuration["AuthSettings:audience"],
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: new SigningCredentials(key, SecurityAlgorithms.HmacSha256)
);
string tokenAsString = new JwtSecurityTokenHandler()
.WriteToken(token);
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", tokenAsString);
return(new RespostaViewModel
{
Mensagem = tokenAsString,
Success = true,
Objeto = token.ValidTo
});
}
public async Task <ActionResult> Login(LoginUsuarioViewModel loginUsuarioVM)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _signInManager.PasswordSignInAsync(loginUsuarioVM.Email, loginUsuarioVM.Senha,
false, true);
if (result.Succeeded)
{
//return Ok(loginUsuarioVM);
var now = DateTime.UtcNow;
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, loginUsuarioVM.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, now.ToUniversalTime().ToString(), ClaimValueTypes.Integer64)
};
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_settings.Value.Secret));
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
ValidateIssuer = true,
ValidIssuer = _settings.Value.Iss,
ValidateAudience = true,
ValidAudience = _settings.Value.Aud,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero,
RequireExpirationTime = true,
};
var jwt = new JwtSecurityToken(
issuer: _settings.Value.Iss,
audience: _settings.Value.Aud,
claims: claims,
notBefore: now,
expires: now.Add(TimeSpan.FromMinutes(2)),
signingCredentials: new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256)
);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var responseJson = new
{
access_token = encodedJwt,
expires_in = (int)TimeSpan.FromMinutes(2).TotalSeconds
};
return(Json(responseJson));
}
if (result.IsLockedOut)
{
return(BadRequest("Usuário temporariamente bloqueado por tentativas inválidas"));
}
return(BadRequest("Usuário ou Senha incorretos"));
}
public async Task <bool> Login(LoginUsuarioViewModel viewModel)
{
var resultadoLogin = await _signInManager.PasswordSignInAsync(viewModel.Email, viewModel.Senha, false, false);
return(resultadoLogin.Succeeded);
}
