public async Task <ActionResult <WebApiResponse> > SignIn([FromBody] UserSignInDTO userDTO)
{
ISigninModelUser signinModelUser = new SigninModelUser(userDTO.Username, userDTO.Password);
ISigninModelResponse signinModelResponse = await _authentication.SignInUser(signinModelUser);
return(new WebApiResponse().Success().SetData(signinModelResponse));
}
public UserSignInResponseDTO UserSignIn(UserSignInRequestDTO userSignInRequestDTO)
{
_logger.LogInformation("UserSignIn email:" + userSignInRequestDTO.Email);
UserSignInDTO userSignInDTO = _mapper.Map <UserSignInDTO>(userSignInRequestDTO);
UserSignInResultDTO userSignInResultDTO = _userService.UserSignIn(userSignInDTO);
return(_mapper.Map <UserSignInResponseDTO>(userSignInResultDTO));
}
public async Task UserSignIn(UserSignInDTO dto)
{
// TODO: add email confirmation
await ValidateUser(dto.Name, dto.Email, dto.Password);
dto.Password = EncryptPassword(dto.Password);
var user = new User(dto.Name, dto.Email, dto.Password);
await _userRepository.Create(user);
}
public async Task <IActionResult> Authenticate(UserSignInDTO userdata)
{
var loginresult = await _authmanager.AuthenticateUserCredentials(userdata.SuppliedUserName.ToLower(), userdata.SuppliedPassword, userdata.VerificationCode);
if (loginresult.ValidatedUser == null)
{
return(CreateUnauthorizedError(loginresult.Error));
}
loginresult.ValidatedUser.Token = _tokenManager.GenerateToken(loginresult.ValidatedUser);
return(Ok(loginresult.ValidatedUser));
}
public async Task When_SignIn_Fail()
{
UserSignInDTO fakeCredentials = new UserSignInDTO
{
Username = _faker.Person.UserName,
Password = _faker.Internet.Password(8)
};
var response = await Helpers.ApiHelper.SendPostRequestAndGetResponse <UserSignInDTO>(
_webClient, SigninUrl, fakeCredentials);
Assert.AreEqual(expected: 401, actual: (int)response.StatusCode);
}
public IActionResult Login([FromBody] UserSignInDTO userSignInDTO)
{
var userRepository = _unitOfWork.Users;
var user = userRepository.GetUserByEmail(userSignInDTO.Email);
if (user == null)
{
return(BadRequest("Invalid email/username or password"));
}
if (userRepository.Authenticate(user, userSignInDTO.Password))
{
return(Ok(userRepository.GenerateJWTToken(user)));
}
return(BadRequest("Invalid email/username or password"));
}
public void RegistrationUser(RegistrationModel registration)
{
UserSignInDTO = new UserSignInDTO
{
Rank = "User",
Login = registration.Login,
Password = registration.Password,
OperationBool = new List <OperationsOfUser <bool> >(1),
OperationChar = new List <OperationsOfUser <char> >(1),
OperationInt = new List <OperationsOfUser <int> >(1),
OperationWord = new List <OperationsOfUser <Word> >(1)
};
IsLogin = true;
}
public async Task <IActionResult> SignIn([FromBody] UserSignInDTO user)
{
var result = await _signInManager.PasswordSignInAsync(user.Email, user.Password, false, false);
if (result == SignInResult.Success)
{
var appUser = await _context.Users.FirstOrDefaultAsync(u => u.Email == user.Email);
string token = GenerateAccessToken(appUser);
return(Ok(token));
}
else
{
return(Unauthorized());
}
}
public async Task <object> Login([FromBody] UserSignInDTO usr)
{
User user = await _context.Users.FirstOrDefaultAsync(u => u.Email == usr.Email);
#region CheckIsNull
if (user == null)
{
return(NotFound());
}
#endregion
#region CheckPasswordIsIncorrect
if (!CryptoHelper.Crypto.VerifyHashedPassword(user.Password, usr.Password))
{
return(StatusCode(401, "Password is incorrect"));
}
#endregion
#region CheckModelIsInvalid
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
#endregion
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration.GetSection("AppSettings:Token").Value);
var tokenDescription = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, user.Id)
}),
Expires = DateTime.Now.AddHours(4),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescription);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new {
id = user.Id,
token = tokenString
}));
}
public void SignInUser(SignInModel signIn)
{
UserSignInDTO = new UserSignInDTO
{
Rank = signIn.Rank,
Login = signIn.Login,
Password = signIn.Password,
OperationBool = new List <OperationsOfUser <bool> >(1),
OperationChar = new List <OperationsOfUser <char> >(1),
OperationInt = new List <OperationsOfUser <int> >(1),
OperationWord = new List <OperationsOfUser <Word> >(1)
};
if (UserSignInDTO.Rank == "User")
{
IsLogin = true;
}
else if (UserSignInDTO.Rank == "Admin")
{
IsLoginSuperUser = true;
}
}
public UserSignInResultDTO UserSignIn(UserSignInDTO userSignInDTO)
{
AccountFindResultDTO accountFindResultDTO = _accountService.Find(userSignInDTO.Email);
//TODO migrate to _accountService
AuthVerifyDTO authVerifyDTO = new AuthVerifyDTO {
ValueRaw = userSignInDTO.Password,
ValueSalt = accountFindResultDTO.PasswordSalt,
ValueHash = accountFindResultDTO.PasswordHash
};
_authService.Verify(authVerifyDTO);
AuthTokenDTO authTokenDTO = new AuthTokenDTO {
SubjectRaw = new Dictionary <string, string>
{
["id"] = userSignInDTO.Email
},
Claims = new Dictionary <string, object>()
};
AuthTokenResultDTO authTokenResultDTO = _authService.AuthToken(authTokenDTO);
return(new UserSignInResultDTO {
Token = authTokenResultDTO.Token
});
}
public async Task <IActionResult> SignIn([FromBody] UserSignInDTO dto)
{
await _userService.UserSignIn(dto);
return(Ok());
}
public ValidationUser(string login, string password, UserSignInDTO user)
{
this.user = user;
this.login = login;
this.password = password;
}
public bool DeleteUser(UserSignInDTO user)
{
return(repository.DeleteUser(user.Login));
}
