public async Task <IActionResult> Login(UserForLoginViewModel userForLoginViewModel)
{
User userFromRepo = await _authRepository.Login(userForLoginViewModel.Username, userForLoginViewModel.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
// token will contains to claims: userid and username
Claim[] claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
// sign the token by creating a security key and encrypting it with a hashing algorithm, and will expire in 24 hrs
SymmetricSecurityKey key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
SigningCredentials creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor()
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
// create the JWT security token handler that allows to create the token based on the token descriptor
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
// finally use this token to write it to the response back to the client
return(Ok(new { token = tokenHandler.WriteToken(token) }));
// to inspect the JWT token, goto jwt.io
}
public async Task <IActionResult> Login(UserForLoginViewModel userForLoginViewModel)
{
var userFromRepo = await _repo.Login(userForLoginViewModel.Username.ToLower(), userForLoginViewModel.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> Login([FromBody] UserForLoginViewModel userForLoginDto)
{
var user = await _userManager.FindByNameAsync(userForLoginDto.UserName);
if (user == null)
{
return(BadRequest("The user doesn't exist !"));
}
var signInResult = await _signInManager.CheckPasswordSignInAsync(user, userForLoginDto.Password, false);
if (!signInResult.Succeeded)
{
return(Unauthorized("Wrong password!. Try again."));
}
user = await _repository.GetUserAsync(user.Id);
var userToListDto = _mapper.Map <UserForListViewModel>(user);
return(Ok(new
{
Token = await GenerateTokenAsync(user),
User = userToListDto
}));
}
public async Task <IActionResult> Login([FromBody] UserForLoginViewModel userForLogin)
{
var userFromService = await _authService.Login(userForLogin);
if (userFromService == null) //User login failed
{
return(Unauthorized());
}
//generate token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_config.GetSection("AppSettings:Token").Value);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.NameIdentifier, userFromService.Id.ToString()),
new Claim(ClaimTypes.Name, userFromService.Username),
new Claim(ClaimTypes.Role, userFromService.RoleName)
}),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new { tokenString }));
}
public async Task <IActionResult> Login(UserForLoginViewModel userForLogig)
{
userForLogig.UserName = userForLogig.UserName.ToLower();
var user = await _userManager.FindByNameAsync(userForLogig.UserName.ToLower());
if (user == null)
{
return(Unauthorized("User dose not exist."));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, userForLogig.Password, false);
if (result.Succeeded)
{
var appUser = _mapper.Map <UserForListDto>(user);
return(Ok(new
{
token = GenerateJwtToken(user),
user = appUser
}));
}
return(Unauthorized("Invalid username or password"));
//HttpContext.Session.SetString("UserId", sessionUser.UserId);
//HttpContext.Session.SetComplexData("SessionUser", sessionUser);
//var sessionUserGet =HttpContext.Session.GetComplexData<SessionUser>("SessionUser");
// var appSettingsSection = _configuration.GetSection("AppSettings:Secret");
// _services.Configure<AppSettings>(appSettingsSection);
//var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetSection("AppSettings:Token").Value));
// var appSettings = appSettingsSection.Get<AppSettings>();
}
public IActionResult Login(UserForLoginViewModel model)
{
var tokenHandler = new JwtSecurityTokenHandler();
var token = _auth.Login(model.Email, model.Password);
if (token == null)
{
return(Unauthorized());
}
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> Login([FromBody] UserForLoginViewModel user)
{
var userFromRepo = await repo.Login(user.UserName, user.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
// Claims
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.UserName)
};
// Key
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes(config.GetSection("AppSettings:Token").Value));
// Credentials
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
/*Security Token descriptor
* Which is going to contain our claims, our expiry date for our Tokens and the Signing credentials */
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(2),
SigningCredentials = creds
};
/* And as well as Token Descriptor we need a token handler */
var tokenHandler = new JwtSecurityTokenHandler();
// Token
var token = tokenHandler.CreateToken(tokenDescriptor);
var userToReturn = mapper.Map <UserForDetailViewModel>(userFromRepo);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
userToReturn
}));
}
public async Task <IActionResult> LoginAsync(UserForLoginViewModel userForLoginViewModel)
{
var userDto = _mapper.Map <UserLoginDto>(userForLoginViewModel);
var user = await _authRepository.LoginAsync(userDto);
if (user == null)
{
return(Unauthorized("ERR_USERNAME_PASSWORD_DONT_EXISTS"));
}
else
{
var appUser = _mapper.Map <UserDto>(user);
return(Ok(new
{
token = GenerateJwtToken(appUser).Result,
appUser
}));
}
}
public async Task <IActionResult> Login(UserForLoginViewModel userForLoginViewModel)
{
try
{
if (ModelState.IsValid)
{
var userFromRepo = await _uow.Users.GetUserByUserNameAsync(userForLoginViewModel.UserName.ToLower());
if (userFromRepo == null)
{
ModelState.AddModelError(string.Empty, "Username or password is incorrect.");
return(View(nameof(Login)));
}
if (!VerifyPasswordHash(userForLoginViewModel.Password, userFromRepo.PasswordHash, userFromRepo.PasswordSalt))
{
ModelState.AddModelError(string.Empty, "Username or password is incorrect.");
return(View(nameof(Login)));
}
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, userFromRepo.UserName),
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(new[] { claimsIdentity });
var authProperties = new AuthenticationProperties
{
IsPersistent = userForLoginViewModel.RememberMe == true ? true : false
};
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, authProperties);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex.StackTrace);
}
return(RedirectToAction("Index", "Home"));
}
public IActionResult Login(UserForLoginViewModel model)
{
var tokenHandler = new JwtSecurityTokenHandler();
var token = _auth.Login(model.Email, model.Password);
if (token == null)
{
return(Unauthorized());
}
string roleName = token.Role.Name;
Guid userId = token.UserID;
string name = token.Name;
//return Ok(new
//{
// token = tokenHandler.WriteToken(token)
//});
return(Ok(jwtHandler.Create(userId, Enum.GetName(typeof(Utility.Role), roleName), name)));
}
public async Task <IActionResult> Login(UserForLoginViewModel userLoginVM)
{
var user = await _userManager.FindByNameAsync(userLoginVM.Username);
var result = await _signInManager.CheckPasswordSignInAsync(user, userLoginVM.Password, false);
if (result.Succeeded)
{
var appUser = await _userManager.Users.Include(p => p.Photos)
.FirstOrDefaultAsync(u => u.NormalizedUserName == userLoginVM.Username.ToUpper());
var userToReturn = _mapper.Map <UserForListViewModel>(appUser);
return(Ok(new
{
token = GenerateJwtToken(appUser).Result,
user = userToReturn
}));
}
return(Unauthorized());
}
public async Task <IActionResult> Login([FromBody] UserForLoginViewModel UserForLoginVM)
{
var UsernameChecker = await _userManager.FindByNameAsync(UserForLoginVM.UserName);
if (UsernameChecker != null)
{
var result = await _signInManager.CheckPasswordSignInAsync(UsernameChecker, UserForLoginVM.Password, false);
if (result.Succeeded)
{
var userToReturn = _mapper.Map <UserToReturnViewModel> (UsernameChecker);
return(Ok(new {
token = GenerateJwtToken(UsernameChecker).Result,
user = userToReturn
}));
}
return(BadRequest("Wrong username or password"));
}
else
{
var EmailChecker = await _userManager.FindByEmailAsync(UserForLoginVM.UserName);
if (EmailChecker != null)
{
var result = await _signInManager.CheckPasswordSignInAsync(EmailChecker, UserForLoginVM.Password, false);
if (result.Succeeded)
{
var userToReturn = _mapper.Map <UserToReturnViewModel> (EmailChecker);
return(Ok(new {
token = GenerateJwtToken(UsernameChecker).Result,
user = userToReturn
}));
}
return(BadRequest("Wrong email or password"));
}
}
return(BadRequest("Wrong username or password"));
}
public async Task <IActionResult> Login(UserForLoginViewModel userForLoginViewModel)
{
var userFromService = await _authService.Login(userForLoginViewModel.UserName, userForLoginViewModel.Password);
bool administrator = await _authService.IsAdministrator(userForLoginViewModel.Password.Trim());
if (userFromService == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromService.USER_GUID.ToString()),
new Claim(ClaimTypes.Name, userFromService.NAME)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
user = userFromService
}));
}
public async Task <UserForLoginViewModel> Login(UserForLoginViewModel user)
{
var loginUser = await _authRepository.Login(user.Username.ToLower(), user.Password);
return(_mapper.Map <UserForLoginViewModel>(loginUser));
}