public async Task Authenticate_User_Success()
{
AuthenticateUserViewModel user = new AuthenticateUserViewModel
{
Email = UserWebApiTest.Email,
Password = UserWebApiTest.Password
};
GetUserViewModel registeredUser = new GetUserViewModel
{
Email = UserWebApiTest.Email,
FirstName = UserWebApiTest.FirstName,
LastName = UserWebApiTest.LastName,
Id = 1,
Token = "token",
};
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: true, errors: null, data: registeredUser);
_userServiceMock.Setup(x => x.AuthenticateAsync(It.IsAny <AuthenticateUserViewModel>()))
.Returns(Task.FromResult(response));
//Act
UserController userController = new UserController(_userServiceMock.Object, _loggerMock.Object);
OkObjectResult result = await userController.AuthenticateUserAsync(user) as OkObjectResult;
//Assert
result.StatusCode.Should()
.Be((int)System.Net.HttpStatusCode.OK);
}
public async Task <AuthenticateUserResultViewModel> AuthenticateAsync(AuthenticateUserViewModel viewModel)
{
var result = await _authenticationService.AuthenticateAsync(viewModel.Email, viewModel.Password);
return(new AuthenticateUserResultViewModel()
{
User = result.User,
Token = result.Token
});
}
public async Task <IActionResult> AuthenticateUserAsync([FromBody] AuthenticateUserViewModel authenticateUserViewModel)
{
Response <GetUserViewModel> response = await _userService.AuthenticateAsync(authenticateUserViewModel);
if (!response.Success)
{
return(BadRequest(response.Errors));
}
return(Ok(response.Data));
}
public async Task <ActionResult> AuthenticateUser([FromBody] AuthenticateUserViewModel authenticateUserViewModel)
{
var users = await Users;
if (_userService.IsValid(users, authenticateUserViewModel.EmailAddress,
authenticateUserViewModel.Password))
{
return(Ok(_userService.GetUser(users, authenticateUserViewModel.EmailAddress)));
}
return(BadRequest());
}
public IActionResult AuthenticateUser([FromBody] AuthenticateUserViewModel request)
{
var jwtToken = _userService.AuthenticateAndGetJwtToken(request.Email, request.Password);
if (string.IsNullOrWhiteSpace(jwtToken))
{
return(BadRequest("User was not found"));
}
Response.Headers.Add("Authorize", jwtToken);
return(Ok());
}
public async Task <Response <GetUserViewModel> > AuthenticateAsync(AuthenticateUserViewModel model)
{
AuthenticateUserViewModelValidator validator = new AuthenticateUserViewModelValidator();
ValidationResult result = validator.Validate(model);
if (!result.IsValid)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: result.Errors.Select(x => x.ErrorMessage).ToArray());
return(response);
}
User user = await _userRepository.GetByEmailAsync(model.Email);
if (user == null)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "This user doesn't exist. " });
return(response);
}
PasswordHasher <User> passwordHasher = new PasswordHasher <User>();
PasswordVerificationResult pvr = passwordHasher.VerifyHashedPassword(user, user.Password, model.Password);
if (pvr == PasswordVerificationResult.Failed)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "Wrong user/password combination, friend. " });
return(response);
}
string token = _tokenService.GenerateToken(user);
GetUserViewModel responseUserViewModel = new GetUserViewModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Token = token,
Email = user.Email,
Guid = user.Guid
};
return(new Response <GetUserViewModel>(success: true, data: responseUserViewModel, errors: null));
}
public async Task <ActionResult <dynamic> > Authenticate([FromBody] AuthenticateUserViewModel viewModel)
{
var user = await _repository.Authenticate(viewModel.Email, viewModel.Password);
if (user == null)
{
return(NotFound(new { message = "Usuário ou senha inválidos" }));
}
var token = TokenServiceAuthentication.GenerateToken(user);
return(new
{
user = _mapper.Map <UserViewModel>(user),
token = token
});
}
public IActionResult Authenticate([FromBody] AuthenticateUserViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _userRepository.Authenticate(viewModel.Username, viewModel.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(AppSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, user.UserId.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials =
new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info and token to client
return(Ok(new
{
user.UserId,
user.Username,
user.FirstName,
user.LastName,
Token = tokenString,
Subscriptions = user.Subscriptions.Select(ue => ue.EstablishmentId),
user.StoreId
}));
}
public async Task Authenticate_User_Fail()
{
AuthenticateUserViewModel user = new AuthenticateUserViewModel
{
Email = UserWebApiTest.Email,
Password = UserWebApiTest.Password
};
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new string[] { "Error" });
_userServiceMock.Setup(x => x.AuthenticateAsync(It.IsAny <AuthenticateUserViewModel>()))
.Returns(Task.FromResult(response));
//Act
UserController userController = new UserController(_userServiceMock.Object, _loggerMock.Object);
BadRequestObjectResult result = await userController.AuthenticateUserAsync(user) as BadRequestObjectResult;
//Assert
result.StatusCode.Should()
.Be((int)System.Net.HttpStatusCode.BadRequest);
}
public IActionResult AuthenticateUser([FromBody] AuthenticateUserViewModel user)
{
_userService.Get(user.Email, user.Password, out string token);
Response.Headers.Add("Authorization", token);
return(Ok(user));
}
