public IActionResult Login([FromBody] LoginInputModel model)
{
var user = repository.GetAll().FirstOrDefault(u => u.Username == model.Username);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!model.Password.Equals(user.Password))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
username = user.Username,
token = authenticationHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginForm model)
{
try
{
LoginUser user = _log.Login(model.UserNameInput);
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!_authHelper.VerifyPasswordHash(model.PasswordInput, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
user = user.UserInfo,
token = _authHelper.GenerateToken(user)
}));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = userService.ReadUsers().FirstOrDefault(u => u.Email == model.Email);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
id = user.ID,
email = user.Email,
token = authenticationHelper.GenerateToken(user),
isAdmin = user.IsAdmin
}));
}
public IActionResult Login([FromBody] LoginUserModel model)
{
var user = _userRepo.GetUser().FirstOrDefault(u => u.Name == model.Username);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!_authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
id = user.Id,
username = user.Name,
role = user.UserType.ToString(),
token = _authenticationHelper.GenerateToken(user)
}));
}
public string AuthenticateUser(LoginInputModel loginInputModel)
{
_loginInputModelValidator.DefaultValidation(loginInputModel);
var user = FindUser(loginInputModel.Username);
if (!_authenticationHelper.VerifyPasswordHash(loginInputModel.Password, user.PasswordHash,
user.PasswordSalt))
{
throw new ArgumentException("Invalid password.");
}
return(_authenticationHelper.GenerateToken(user));
}
public ActionResult Login([FromBody] LoginInputModel loginInputModel)
{
try
{
User user = _userService.Validate(loginInputModel);
string token = _authenticationHelper.GenerateToken(user);
return(Ok(new { user.Username, token }));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public String ValidateUser(Tuple <string, string> attemptToLogin)
{
//Checks if the user is valid, first, otherwise it's gonna return invalid and checks the first item, which is the username.
var user = CheckForValidUser(attemptToLogin.Item1);
//Next, if there's no verified hashed and salted password, which is equal to the password of the login,
//it's gonna throw an exception.
if (!_authentication.VerifyPasswordHash(attemptToLogin.Item2, user.PasswordHash, user.PasswordSalt))
{
throw new ArgumentException("Invalid password");
}
var claims = SetUpClaims(user);
//Generate refresh token and save it for user.
return(_authentication.GenerateToken(claims));
}
public IActionResult Login([FromBody] LoginInputModel loginmodel)
{
var user = userRepository.GetAll().FirstOrDefault(u => u.Username == loginmodel.Username);
if (user == null)
{
return(Unauthorized());
}
if (!authenticationHelper.VerifyPasswordHash(loginmodel.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
return(Ok(new
{
username = user.Username,
token = authenticationHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = userService.GetUserByEmail(model.Username);
if (user == null)
{
return(Unauthorized());
}
if (!authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
user.PasswordSalt = user.PasswordHash = null;
return(Ok(new
{
User = user,
token = authenticationHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _userService.GetAllUsers().FirstOrDefault(u => u.Username == model.Username);
if (user == null)
{
return(Unauthorized());
}
if (!_authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
return(Ok(new
{
username = user.Username,
token = _authenticationHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _userRepo.GetAll().FirstOrDefault(u => u.Username == model.Username);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
if (!_authenHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
username = user.Username,
token = _authenHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _log.Login(model.Username);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
username = user.Username,
token = authenticationHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _userService.getUsers().FirstOrDefault(u => u.Username == model.Username);
//Cheking if user exists
if (user == null)
{
return(Unauthorized());
}
//Chek if pass is correct
if (!_authHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
//Authentication successfull
return(Ok(new
{
username = user.Username,
token = _authHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _userService.GetUserFromLoginInput(model);
// check if username exists
if (user == null)
{
return(Unauthorized("Login fejlede. Tjek venligst at brugernavn og adgangskode er korrekt."));
}
// check if password is correct
if (!_authHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized("Login fejlede. Tjek venligst at brugernavn og adgangskode er korrekt."));
}
// Authentication successful
return(Ok(new
{
username = user.Username,
token = _authHelper.GenerateToken(user)
}));
}
public IActionResult Login([FromBody] LoginInputModel model)
{
var user = _userRepository.ReadUsers().FirstOrDefault(p => p.Username == model.Username);
// check if username exists
if (user == null)
{
return(Unauthorized());
}
// check if password is correct
if (!_authenticationHelper.VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
{
return(Unauthorized());
}
// Authentication successful
return(Ok(new
{
username = user.Username,
isAdmin = user.IsAdmin,
token = _authenticationHelper.GenerateToken(user)
}));
}
public async Task <LoginResultModel> LoginAsync(LoginModel loginModel)
{
if (loginModel == null || string.IsNullOrEmpty(loginModel.UserName) || string.IsNullOrEmpty(loginModel.Password))
{
throw new ArgumentException("Invalid arguments.");
}
loginModel.Password = _authenticationHelper.HashPassword(loginModel.Password);
UserModel userModel = await _loginDal.GetUserByUsernameAndPasswordAsync(loginModel);
if (userModel == null)
{
throw new Exception("User not exists.");
}
userModel.Password = "******";
string token = _authenticationHelper.GenerateToken(userModel.ID);
return(new LoginResultModel()
{
UserModel = userModel, Token = token
});
}
public string GenerateToken(User user)
{
return(_authenticationHelper.GenerateToken(user));
}
