public async Task <IActionResult> Register(LoginModelDto model)
{
try
{
if (_signInManager.IsSignedIn(User))
{
return(BadRequest("Already logged in"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
UserName = model.Username
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok("Registered"));
}
return(BadRequest(result.Errors));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Login(LoginModelDto model)
{
try
{
if (_signInManager.IsSignedIn(User))
{
return(BadRequest("Already logged in"));
}
var loginResult = await _signInManager.PasswordSignInAsync(model.Username, model.Password, true, false);
if (loginResult.Succeeded)
{
var user = await _userManager.FindByNameAsync(model.Username);
var result = new LoginModelDto
{
Id = user.Id,
Username = user.UserName
};
return(Ok(result));
}
return(BadRequest("Couldn't log in"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <UserModelDto> > Login([FromBody] LoginModelDto model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
throw new Exception("user authentication error ");
}
var result = await _signInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
return(new UserModelDto
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
UserName = user.UserName,
EmailConfirmed = user.EmailConfirmed,
JwtToken = _jwtToken.CreateToken(user),
});
}
throw new Exception("not authorize");
}
public async Task <ActionResult <string> > PostLogin(LoginModelDto usuarioLogin)
{
var datosLoginUsuario = _mapper.Map <Usuario>(usuarioLogin);
var resultadoValidacion = await _usuariosRepositorio.ValidarDatosLogin(datosLoginUsuario);
if (!resultadoValidacion.resultado)
{
return(BadRequest("Usuario/Contraseña Inválidos."));
}
return(_tokenService.GenerarToken(resultadoValidacion.usuario));
}
public async Task <IActionResult> IsAuthenticated()
{
var user = await _userManager.FindByIdAsync(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var result = new LoginModelDto
{
Id = user.Id,
Username = user.UserName
};
return(Ok(result));
}
public async Task <IActionResult> Authenticate([FromBody] LoginModelDto login)
{
try {
if (login == null || String.IsNullOrEmpty(login.Username) || String.IsNullOrEmpty(login.Password))
{
throw new Exception("Invalid credentials");
}
string token = await _authManager.Authenticate(login.Username, login.Password);
return(String.IsNullOrEmpty(token) ? (IActionResult)Unauthorized() : Ok(new { token }));
} catch (Exception error) {
return(BadRequest(error));
}
}
public UserDto Login(LoginModelDto loginModel)
{
CreateAdminIfNotExists();
var user = _unitOfWork.Users.Find(u => u.Email.Equals(loginModel.Email)).FirstOrDefault();
if (user == null || !_cryptoProvider.VerifyHash(loginModel.Password, user.PasswordHash))
{
throw new ServiceException("Invalid password", "Password");
}
var userDto = _mapper.Map <UserDto>(user);
return(userDto);
}
public UserDto Login(LoginModelDto loginModel)
{
var user = _unitOfWork.Users.Find(u => u.Email.Equals(loginModel.Email)).FirstOrDefault();
if (user == null || !_cryptoProvider.VerifyHash(loginModel.Password, user.PasswordHash))
{
throw new ServiceException("Invalid password", "Password");
}
var userDto = _mapper.Map <UserDto>(user);
_logger.LogInformation($"User login with email {loginModel.Email}");
return(userDto);
}
public async Task <IActionResult> PostCambiarContrasena(LoginModelDto usuarioContrasenaDto)
{
try
{
var usuario = _mapper.Map <Usuario>(usuarioContrasenaDto);
var resultado = await _usuariosRepositorio.CambiarContrasena(usuario);
if (!resultado)
{
return(BadRequest());
}
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public async Task <IActionResult> UserLogin(LoginModelDto model)
{
try
{
var loginResult = await _userManagerService.UserLogin(model);
if (loginResult == null)
{
var res = new ResponseDataObject
{
Message = "Authentication failed!",
Status = false,
};
return(Ok(res));
}
if (loginResult.IsActived)
{
var res = new ResponseDataObject <LoginResponse>
{
Data = loginResult,
Message = "Login was successful",
Status = true,
};
return(Ok(res));
}
if (!loginResult.IsSuccess)
{
var res = new ResponseDataObject <LoginResponse>
{
Data = loginResult,
Message = "Your Account is not activated yet!",
Status = true,
};
return(Ok(res));
}
return(BadRequest("User login failed!"));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> Login(LoginModelDto loginModelDto)
{
var user = await _userManager.FindByNameAsync(loginModelDto.Username);
var result = await _signInManager.CheckPasswordSignInAsync(user, loginModelDto.Password, false);
if (result.Succeeded)
{
var appUser = _mapper.Map <UserForListDto>(user);
return(Ok(new
{
token = GenerateJwtToken(user),
user = appUser
}));
}
return(Unauthorized("Unauthorized user"));
}
public async Task <ActionResult <UsuarioRegistroDto> > PostValidarUsuario(LoginModelDto usuarioContrasenaDto)
{
try
{
var usuario = _mapper.Map <Usuario>(usuarioContrasenaDto);
var resultado = await _usuariosRepositorio.ValidarContrasena(usuario);
if (!resultado)
{
return(BadRequest());
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest());
}
}
/// <summary>
/// Generates a token
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public async Task <string> GenerateToken(LoginModelDto user)
{
//Generating Token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes("Super Secret Key");
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
//new Claim(),
new Claim(ClaimTypes.Name, user.EmailAddress)
}),
Expires = DateTime.Now.AddDays(2),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(await Task.FromResult(tokenString));
}
public async Task <LoginResponse> UserLogin(LoginModelDto modelDto)
{
LoginResponse response;
var checkUser = await CheckUserExists(u => u.EmailAddress == modelDto.EmailAddress || u.PhoneNo == modelDto.PhoneNo);
if (checkUser != null)
{
var verifyPass = VerifyPasswordHash(modelDto.Password, checkUser.PaswordHash, checkUser.PasswordSalt);
if (verifyPass)
{
var status = await IsActivated(x => (x.EmailAddress == modelDto.EmailAddress || x.PhoneNo == modelDto.PhoneNo) && x.IsActivated == true);
if (status)
{
var token = await GenerateToken(modelDto);
//if user has account and is activated
response = new LoginResponse
{
Token = token,
EmailAddress = modelDto.EmailAddress,
IsActived = status,
IsSuccess = true
};
return(response);
}
//if user has account and is not activated
response = new LoginResponse
{
Token = null,
EmailAddress = modelDto.EmailAddress,
IsActived = status,
IsSuccess = false
};
return(response);
}
}
//if user does not have account
return(null);
}
public async Task <IActionResult> CreateToken([FromBody] LoginModelDto dto)
{
IActionResult response = Unauthorized();
var user = await _authSvc.LoginAsync(dto.Email, dto.Password);
if (user == null)
{
return(response);
}
var userDto = _mapper.Map <UserModelDto>(user);
userDto.Token = _authSvc.BuildJwtToken(user);
userDto.RefreshToken = _authSvc.BuildRefreshToken();
await _authSvc.AddRefreshTokenAsync(userDto.RefreshToken, user.Email);
response = Ok(userDto);
return(response);
}
public async Task <IActionResult> CreateToken([FromBody] LoginModelDto login)
{
var user = await _wpbService.AuthenticateAsync(login.Username, login.Password);
if (user == null)
{
return(BadRequest(new ApiError(400, "BadRequest", "Username or password was incorrect.")));
}
var tokenString = GenerateToken(user);
return(Ok(
new
{
Id = user.Id.ToString(),
user.Username,
user.FirstName,
user.Email,
Token = tokenString
}));
}
public void Login_ThrowsServiceException_IfPasswordIsNotValid()
{
var loginModel = new LoginModelDto {
Password = "******"
};
var users = new List <User> {
new User {
PasswordHash = "hash-stub"
}
};
_unitOfWorkMock
.Setup(unitOfWork => unitOfWork.Users.Find(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(users.AsQueryable());
_cryptoProviderMock
.Setup(provider => provider.VerifyHash(loginModel.Password, users[0].PasswordHash))
.Returns(false);
Assert.Throws <ServiceException>(() => _sut.Login(loginModel));
}
public async Task <IActionResult> Login([FromBody] LoginModelDto model)
{
var user = await userManager.FindByNameAsync(model.Username);
if (user != null && await userManager.CheckPasswordAsync(user, model.Password))
{
var userRoles = await userManager.GetRolesAsync(user);
var authClaims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim("UserID", user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
};
foreach (var userRole in userRoles)
{
authClaims.Add(new Claim(ClaimTypes.Role, userRole));
}
var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:Secret"]));
var token = new JwtSecurityToken(
issuer: _configuration["JWT:ValidIssuer"],
audience: _configuration["JWT:ValidAudience"],
expires: DateTime.Now.AddHours(3),
claims: authClaims,
signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
return(Unauthorized());
}
public void Login_ReturnsUser_IfLoginModelIsValid()
{
var loginModel = new LoginModelDto {
Email = "email-sub", Password = "******"
};
var users = new List <User> {
new User {
Email = "email-sub", PasswordHash = "hash-stub"
}
};
_unitOfWorkMock
.Setup(unitOfWork => unitOfWork.Users.Find(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(users.AsQueryable());
_cryptoProviderMock
.Setup(provider => provider.VerifyHash(loginModel.Password, users[0].PasswordHash))
.Returns(true);
var result = _sut.Login(loginModel);
Assert.Equal(result.Email, users[0].Email);
}
public async Task <UserManagerResponse> Login([FromBody] LoginModelDto model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(new UserManagerResponse
{
IsSucces = false,
Message = "User with such email doesn't exist"
});
}
var checkingPasswordResult = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (checkingPasswordResult.Succeeded)
{
return(await JwtService.GenerateJwt(user, _userManager, _authenticationOptions));
}
return(new UserManagerResponse
{
Message = "Incorect password"
});
}
public ClaimsIdentity GetClaimIdentity(LoginModelDto loginModelDto)
{
var user = _userManager.FindUser(loginModelDto.Login, loginModelDto.Password);
return(_userManager.CreateIdentity(user));
}
public bool CheckUser(LoginModelDto loginModelDto)
{
var user = _userManager.FindUser(loginModelDto.Login, loginModelDto.Password);
return(user == null ? false : true);
}
public bool IsAccountActive(LoginModelDto loginDto)
{
return(_userManager.IsAccountActive(loginDto.Login));
}
