public async Task <ActionResult <UserLoginResultDto> > SignIn([FromBody] UserLoginDto user)
{
var command = new LoginUserCommand
{
Email = user.Email,
Password = user.Password
};
var loginResult =
await _mediator.Send(command);
var result = new UserLoginResultDto
{
Email = loginResult.Email,
UserId = loginResult.UserId,
IsSuccessed = loginResult.IsSucceeded,
IsLocked = loginResult.IsLocked
};
if (!loginResult.IsSucceeded || loginResult.IsLocked)
{
return(result);
}
result.Token = _userService.GenerateToken(loginResult.Email);
return(Ok(result));
}
public Task <CommandResult <User> > Handle(LoginUserCommand request, CancellationToken cancellationToken)
{
var response = new CommandResult <User>("Login realizado com sucesso", true, null);
request.Validate();
if (request.Valid)
{
User user = new User(request.Email, request.Senha);
if (user.Valid)
{
var result = _userRepository.GetAll().FirstOrDefault(x => x.email == request.Email && x.senha == request.Senha);
if (result != null)
{
response.Sucesso = true;
response.ObjetoResposta = result;
return(Task.FromResult(response));
}
else
{
response.Sucesso = false;
response.Mensagem = "Login ou senha inválidos!";
return(Task.FromResult(response));
}
}
response.Notificacoes.AddRange(user.Notifications.Select(x => x.Message).ToList());
}
response.Notificacoes.AddRange(request.Notifications.Select(x => x.Message).ToList());
response.Sucesso = false;
response.Mensagem = "Não foi possível realizar o Login.";
return(Task.FromResult(response));
}
public async Task <AuthenticationResult> LoginAsync(LoginUserCommand loginUser)
{
var user = await _userManager.FindByEmailAsync(loginUser.Email);
if (user == null)
{
return new AuthenticationResult
{
Errors = new[] { "User does not exist" }
}
}
;
var userHasValidPassword = await _userManager.CheckPasswordAsync(user, loginUser.Password);
if (!userHasValidPassword)
{
return new AuthenticationResult
{
Errors = new[] { "User/password combination is wrong" }
}
}
;
return(await GenerateAuthenticationResultForUserAsync(user));
}
public UserViewModel()
{
this.user = new User("bob", "123");
LoginCommand = new LoginUserCommand(this);
NewUserCommand = new CreateUserCommand(new UserCreationViewModel());
}
public GetLoggedUserResult Handle(LoginUserCommand command)
{
_repository.MockDataCreator(); //note: comment THIS LINE to avoid the creation of FAKE MockData
command.Validate();
if (command.Invalid)
{
return(new GetLoggedUserResult(false, "Cannot login because invalid information", "", "", "", "", null));
}
var user = _repository.GetByLogin(command.UserName);
if (user == null)
{
return(new GetLoggedUserResult(false, "Cannot find UserName or Password", "", "", "", "", null));
}
if (!user.UserAccount.Authenticate(command.UserName, command.Password))
{
return(new GetLoggedUserResult(false, "Cannot find UserName or Password", "", "", "", "", null));
}
// If pass, user was authenticated, so i need to get the claims
var userClaim = _userClaimRepository.GetByUser(user);
List <string> Claims = new List <string>();
foreach (UserClaim item in userClaim)
{
Claims.Add(item.Claim.ClaimName);
}
//TO-DO: Need to load the CLAIMS here and return on Obj instead of user
return(new GetLoggedUserResult(true, "Logged with Success.", user.Id.ToString(), user.Name.ToString(), user.Email.EmailAddress.ToString(), user.UserAccount.UserName, Claims));
}
public IActionResult Login([FromBody] LoginUserCommand user)
{
if (user == null)
{
return(BadRequest("Invalid client request"));
}
var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["AppSettings:SecretKey"]));
//IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["AppSettings:JwtKey"])),
var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256Signature);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.Email),
};
var tokeOptions = new JwtSecurityToken(
_configuration["Issuer"],
_configuration["Audiance"],
claims,
expires: DateTime.Now.AddMinutes(5),
signingCredentials: signinCredentials
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(tokeOptions);
return(Ok(new { Token = tokenString }));
}
public async Task <Result <LoginOutputModel> > Login(LoginUserCommand userInput)
{
var user = await userManager.FindByEmailAsync(userInput.Email);
if (user == null)
{
return(IdentityErrors.InvalidLogin);
}
var passwordValid = await userManager.CheckPasswordAsync(user, userInput.Password);
if (!passwordValid)
{
return(IdentityErrors.InvalidLogin);
}
var userRoles = await this.userManager.GetRolesAsync(user);
var claimRoles = new List <Claim>();
if (userRoles.Any())
{
foreach (var roleName in userRoles)
{
claimRoles.Add(new Claim(ClaimTypes.Role, roleName));
}
}
var token = jwtTokenGenerator.GenerateToken(user, claimRoles);
return(new LoginOutputModel(token));
}
public async Task <IActionResult> Login(LoginUserCommand model)
{
var result = await this.Mediator.Send(model);
this.SetCookies(result.Data.Token, result.Data.RefreshToken.ToString());
return(this.Ok(result));
}
public async Task InputDataIsok_Executed_LoginUserViewModel()
{
var fixture = new Fixture();
var userRepository = new Mock <IUserRepository>();
var authService = new Mock <IAuthService>();
var user = new User(1, "abc", "*****@*****.**", "123", "admin");
var userEmail = user.Email;
var userPassword = user.Password;
userRepository.Setup(u => u.GetUserByEmailAndPasswordAsync(user.Email, user.Password))
.Returns(ConverUserInTaskUser(user));
authService.Setup(u => u.ComputeSha256Hash(user.Password)).Returns(user.Password);
authService.Setup(u => u.GenerateJwtToken(user.Email, user.Role)).Returns("asdasfsdfkjldhl");
var loginUserCommand = new LoginUserCommand(userEmail, userPassword);
var loginUserCommandHandler = new LoginUserCommandHandler(authService.Object, userRepository.Object);
var userViewModel = await loginUserCommandHandler.Handle(loginUserCommand, new System.Threading.CancellationToken());
Assert.IsType <LoginUserViewModel>(userViewModel);
Assert.NotNull(userViewModel.Token);
Assert.NotEmpty(userViewModel.Token);
userRepository.Verify(g => g.GetUserByEmailAndPasswordAsync(userEmail, userPassword), Times.Once);
authService.Verify(g => g.ComputeSha256Hash(user.Password), Times.Once);
authService.Verify(g => g.GenerateJwtToken(user.Email, user.Role), Times.Once);
}
public async Task LoginAsyncSignInSuccessedCreateJwtToken(UserTypeEnum userType)
{
var command = new LoginUserCommand()
{
Email = _faker.Person.Email,
Password = _faker.Internet.Password(),
TokenId = _faker.Random.Guid()
};
var userName = UserHelper.GetUserName(userType, command.Email);
var user = new User()
{
Id = 1
};
var jwtToken = "";
_userManagerMock.Setup(x => x.FindByNameAsync(userName)).ReturnsAsync(user);
_signInManagerMock.Setup(x => x.PasswordSignInAsync(user, command.Password, false, false)).ReturnsAsync(SignInResult.Success);
_jwtHandlerMock.Setup(x => x.CreateToken(user.Id, userType.ToString())).Returns(jwtToken);
var err = await Record.ExceptionAsync(async() => await _userService.LoginAsync(userType, command));
err.Should().BeNull();
_signInManagerMock.Verify(x => x.PasswordSignInAsync(user, command.Password, false, false), Times.Once);
_jwtHandlerMock.Verify(x => x.CreateToken(user.Id, userType.ToString()), Times.Once);
}
public async Task <IActionResult> Login([FromBody] LoginUserCommand command)
{
Logger.LogInformation("{Message} {Username}", "Trying to login user", command.Username);
var result = await Mediator.Send(command);
if (!result.IsSucceeded)
{
Logger.LogWarning("{Message} {ErrorMessage} {Username} ",
"Failed at login user", result.Errors.Values, command.Username);
return(GetResponse(result));
}
var userData = result.Data;
var response = new ApiLoginResponse
{
Id = userData.Id,
Username = userData.Username,
Email = userData.Email,
Token = _tokenGenerator.GenerateTokenForUser(userData)
};
Logger.LogInformation("{Message} {UserId} {Username}",
"Successful login for user", userData.Id, userData.Username);
return(Ok(response));
}
public async Task <BaseResponse <LoginUserCommandResponse> > LogInAsync(
[FromBody] LoginUserCommand command)
{
var signInResult = await signInManager.PasswordSignInAsync(command.Login, command.Password, true, false);
if (signInResult.Succeeded)
{
var claims = new List <Claim> {
new Claim(ClaimsIdentity.DefaultNameClaimType, command.Login)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await httpContextAccessor.HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
var isAdmin = await userService.IsAdmin(command.Login);
return(new BaseResponse <LoginUserCommandResponse>
{
Result = new LoginUserCommandResponse
{
Success = true,
IsAdmin = isAdmin
}
});
}
return(new BaseResponse <LoginUserCommandResponse> {
Error = "Неверный логин или пароль"
});
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
Stopwatch a = new Stopwatch();
a.Start();
var data = new LoginUserCommand {
Email = "*****@*****.**", Password = "******"
};
ApiHelper api = new ApiHelper("https://localhost:44348/");
var result = await api.PostAsync <Result <LoginUserViewModel> >("api/Account/login", data);
var accessToken = result.Data.Token;
Console.WriteLine(accessToken);
api.AddJwtAuthorization(accessToken);
//var allProducts = await apiAuth.GetAsync<Result<IEnumerable<ProductViewModel>>>("api/v1/Product");
var productOne = await api.GetAsync <Result <ProductViewModel> >("api/v1/Product/1");
var productTwo = await api.GetAsync <Result <ProductViewModel> >("api/v1/Product/2");
api.RemoveJwtAuthorization();
var productThree = await api.GetAsync <Result <ProductViewModel> >("api/v1/Product/3");
await api.GetAsync <Result <ProductViewModel> >("api/v1/Product/3");
a.Stop();
Console.WriteLine(a.ElapsedMilliseconds);
Console.ReadLine();
}
public async Task InputDataIsOk_Executed_ReturnLoginUserViewModel()
{
//Arrange
var loginUserCommand = new LoginUserCommand
{
Email = "*****@*****.**",
Password = "******"
};
var user = new User("Nome de teste", loginUserCommand.Email, Convert.ToDateTime("15/12/1993"), loginUserCommand.Password, "client");
var token = "adsadsa5d56asda564das564da5s64d56a4ds456";
var authServiceMock = new Mock <IAuthService>();
var userRepositoryMock = new Mock <IUserRepository>();
var loginUserCommandHandler = new LoginUserCommandHandler(authServiceMock.Object, userRepositoryMock.Object);
authServiceMock.Setup(u => u.ComputeSha256Hash(loginUserCommand.Password)).Returns(loginUserCommand.Password);
authServiceMock.Setup(u => u.GenerateJwtToken(loginUserCommand.Email, user.Role)).Returns(token);
userRepositoryMock.Setup(u => u.LoginAsync(loginUserCommand.Email, loginUserCommand.Password).Result).Returns(user);
//Act
var loginUserViewModel = await loginUserCommandHandler.Handle(loginUserCommand, new CancellationToken());
//Assert
Assert.NotNull(loginUserViewModel);
userRepositoryMock.Verify(u => u.LoginAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
authServiceMock.Verify(a => a.GenerateJwtToken(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public async Task <Result <UserLoggedInDto> > Handle(LoginUserCommand request, CancellationToken cancellationToken)
{
var userForLoginDto = request.UserForLoginDto;
var wrongPasswordResult = Result <UserLoggedInDto> .Unauthorized("Username or password are wrong.");
var user = await _repo.GetUserByUserName(userForLoginDto.UserName);
if (user == null)
{
return(wrongPasswordResult);
}
bool isPasswordCorrect = user.ValidateIfPasswordIsCorrect(userForLoginDto.Password);
if (isPasswordCorrect == false)
{
return(wrongPasswordResult);
}
var userClaims = user.GetClaims();
var userLoggedInDto = new UserLoggedInDto
{
JwtToken = _tokenCreator.GenerateJwtToken(userClaims),
User = _mapper.Map <UserForDetailDto>(user)
};
return(Result <UserLoggedInDto> .Success(userLoggedInDto));
}
public async Task GivenAUserLoginRequest_WhenUserExistsAndPasswordIsValid_ReturnsUserViewModelAndSuccessfulResponse()
{
// Arrange
var userLoginCommand = new LoginUserCommand
{
User = new UserLoginDto
{
Email = "*****@*****.**",
Password = "******"
}
};
var requestContent = ContentHelper.GetRequestContent(userLoginCommand);
// Act
var response = await Client.PostAsync(LoginEndpoint, requestContent);
var responseContent = await ContentHelper.GetResponseContent <UserViewModel>(response);
// Assert
response.EnsureSuccessStatusCode();
responseContent.ShouldNotBeNull();
responseContent.ShouldBeOfType <UserViewModel>();
responseContent.User.Email.ShouldBe(userLoginCommand.User.Email);
responseContent.User.Token.ShouldNotBeEmpty();
}
public async Task <LoginUserResponse> Login(LoginUserCommand loginUserResource)
{
try
{
var userFromRepository = await _authRepository.Login(loginUserResource.Email.ToLower(), loginUserResource.Password);
if (userFromRepository != null)
{
//generate token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration.GetSection("AppSettings:Token").Value);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.NameIdentifier, userFromRepository.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepository.Email)
}),
Expires = DateTime.Now.AddHours(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(new LoginUserResponse(userFromRepository, tokenString));
}
return(new LoginUserResponse("Unauthorized"));
}
catch (Exception ex)
{
return(new LoginUserResponse($"An error occurred when loging the user: {ex.Message}"));
}
}
// [LogAspect(typeof(FileLogger))]
public async Task <IDataResult <LoginUserResult> > Handle(LoginUserCommand request, CancellationToken cancellationToken)
{
// Uygun providerı al ve login ol.
var provider = coordinator.SelectProvider(request.Provider);
return(new SuccessDataResult <LoginUserResult>(await provider.Login(request)));
}
public ExtendedLoginUserCommand(LoginUserCommand command, string ipAddress)
{
this.Email = command.Email;
this.Username = command.Username;
this.Password = command.Password;
this.RemoteIpAddress = ipAddress;
}
public async Task <UserDTO> Login(LoginFilter filter, CancellationToken cancellationToken = default)
{
try
{
var user = await _userQueryHandler.HandleAsync(filter, cancellationToken);
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (!user.Active)
{
throw new InvalidOperationException("user is currently not active.");
}
// create token data
var tokenData = new TokenData(user.Company, user.Name, user.Email, user.CPF);
// create and save a token for the logged user
user.Token = _securityTokenService.CreateToken(tokenData);
var loginCommand = new LoginUserCommand(user.Id, user.Token);
await _userCommandHandler.ExecuteAsync(loginCommand, cancellationToken);
return(user);
}
catch (Exception ex)
{ throw ex; }
}
public async Task <IActionResult> Post([FromBody] LoginUserCommand command)
{
await Send(command);
var jwt = _cache.GetJwt(command.Email);
return(Json(jwt));
}
public async Task <IActionResult> RegisterWithInvitation(
[FromBody] LoginUserCommand command,
CancellationToken ct)
{
await Mediator.Send(command, ct);
return(Ok("Account created!"));
}
public void Have_Validation_Error_When_Password_Is_Null_Or_Empty(string password)
{
var expectedCommand = new LoginUserCommand("*****@*****.**", password);
var actualResult = _sut.TestValidate(expectedCommand);
actualResult.ShouldHaveValidationErrorFor(user => user.Password.Value);
}
public void Have_Validation_Error_When_Email_Is_Null_Or_Empty_Or_Invalid(string email)
{
var expectedCommand = new LoginUserCommand(email, "pass");
var actualResult = _sut.TestValidate(expectedCommand);
actualResult.ShouldHaveValidationErrorFor(user => user.Email.Value);
}
public async Task LogInAsync(LoginUserCommand command)
{
var result = await _client.PostJsonAsync <TokenResponse>("/api/auth/Login", command);
if (!string.IsNullOrEmpty(result.token))
{
await _tokenService.SaveAccessToken(result.token);
}
}
public async Task <UserLoginData> LoginAsync(LoginUserCommand command)
{
var user = await _userRepository.GetWithGroupTeamsAndStudents(command.Email);
if (user == null)
{
throw new AppException("Wrong email or password.", AppErrorCode.VALIDATION_ERROR);
}
string generatedHash = _encrypter.GetHash(command.Password, user.Salt);
if (user.PasswordHash != generatedHash)
{
throw new AppException("Wrong email or password.", AppErrorCode.VALIDATION_ERROR);
}
JwtDto token = _jwtHandler.CreateToken(user.Id, user.Role);
var userData = new UserLoginData
{
Token = token,
User = new LoginUser
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Groups = user.Groups.Select(g => new LoginGroupDto
{
Id = g.Id,
UserRoles = new List <RoleDto>(),
Name = g.Name,
Teams = g.Teams.Select(t => t.Name).ToList(),
UserTeams = g.Teams.Where(t =>
t.Students.Any(s => s.Id == user.Id))
.Select(t => t.Name).ToList()
}).ToList()
}
};
for (int i = 0; i < user.Groups.Count(); i++)
{
if (user.Groups.ElementAt(i).Students.Any(s => s.Id == user.Id))
{
userData.User.Groups.ElementAt(i).UserRoles.Add(RoleDto.Student);
}
if (user.Groups.ElementAt(i).Moderators.Any(s => s.Id == user.Id))
{
userData.User.Groups.ElementAt(i).UserRoles.Add(RoleDto.Moderator);
}
if (user.Groups.ElementAt(i).Administrators.Any(s => s.Id == user.Id))
{
userData.User.Groups.ElementAt(i).UserRoles.Add(RoleDto.Administrator);
}
}
return(userData);
}
public async Task <IActionResult> Handle(LoginUserCommand request)
{
var response = await Mediator.Send(request);
return(Ok(new {
AccessToken = response.AccessToken,
RefreshToken = response.RefreshToken,
Message = "Acceso realizado con éxito"
}));
}
public async Task <IActionResult> Login([FromBody] LoginUserCommand command)
{
var result = await Mediator.Send(command);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Login(LoginUserCommand command)
{
try {
var result = await _mediator.Send(command);
return(Ok(result));
} catch (Exception e) {
return(BadRequest(e.Message));
};
}
public async Task <ActionResult <CommandResult <User> > > VerificarUsuario([FromBody] LoginUserCommand command)
{
var response = await _mediator.Send(command);
if (response.Sucesso)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> Login([FromBody] LoginUserCommand command)
{
var loginUserViewModel = await _mediator.Send(command);
if (loginUserViewModel == null)
{
return(BadRequest());
}
return(Ok(loginUserViewModel));
}
public void LoginUser_With_Correct_Password_And_Unverified()
{
const string email = "*****@*****.**";
var createCommand = new CreateClientCommand("test", email, "123456", "brag", 3.2342, 23.4545, 1);
ExecuteCommand(createCommand);
var loginUserCommand = new LoginUserCommand(email, "123456");
ExecuteCommand(loginUserCommand);
Assert.IsNull(loginUserCommand.Result);
}
public void LoginUser_With_Incorrect_Password_But_Verified()
{
const string email = "*****@*****.**";
var createCommand = new CreateClientCommand("test", email, "123456", "brag", 3.2342, 23.4545, 1);
ExecuteCommand(createCommand);
var client = Session.QueryOver<Client>().Where(c => c.Email == email).SingleOrDefault();
client.IsVerified = true;
Session.Update(client);
var loginUserCommand = new LoginUserCommand(email, "12345678");
ExecuteCommand(loginUserCommand);
Assert.AreEqual(1, loginUserCommand.Result.RetryCount);
}
/* Callback */
static void StartCommunication()
{
Console.WriteLine("***** Test HTTP CALLBACK Client *****");
Console.WriteLine("\n\nPress a key to start the communication");
Console.ReadLine();
User testUser1 = userList.ElementAt(0);
UserNodeCore testClient1 = uncList.ElementAt(0);
LoginUserCommand login = new LoginUserCommand(testUser1.UserName, testUser1.Password);
testClient1.ConnectToService(login);
Console.WriteLine("\n\n\nClient is now ready to perform some other task");
User testUser2 = userList.ElementAt(1);
UserNodeCore testClient2 = uncList.ElementAt(1);
Console.WriteLine("\n\n\nProvo a connettermi....");
testClient2.ConnectToService(login);
Console.WriteLine("\n\n\nConnessione effettuata!");
}
