public async Task <ActionResult <AppUser> > Login(LoginDTO loginDto)
{
var user = await _context.Users.SingleOrDefaultAsync(x => x.Username == loginDto.Username);
if (user == null)
{
return(Unauthorized("Invalid Username"));
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.Password));
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != user.PasswordHash[i])
{
return(Unauthorized("Invalid"));
}
}
return(user);
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _userManager.Users.Include(u => u.Photos).FirstOrDefaultAsync(u => u.Email == loginDTO.Email);
//.FindByEmailAsync(loginDTO.Email);
if (user == null)
{
return(Unauthorized());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (result.Succeeded)
{
return(CreateUserObject(user));
}
return(Unauthorized());
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _userManager.FindByEmailAsync(loginDTO.Email);
if (user == null)
{
return(Unauthorized("No account found with this email address"));
}
var authentication = await _signInManager.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (!authentication.Succeeded)
{
return(Unauthorized("Wrong email or password"));
}
return(new UserDTO
{
Email = user.Email,
Token = _tokenService.CreateToken(user),
DisplayName = user.DisplayName
});
}
public async Task <ActionResult <UserDTO> > Login([FromBody] LoginDTO loginDTO)
{
var user = await _userManager.FindByEmailAsync(loginDTO.Email);
if (user == null)
{
return(BadRequest());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
return(new UserDTO
{
DisplayName = user.DisplayName,
Email = user.Email,
Token = _tokenService.CreateToken(user)
});
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _userManager.FindByEmailAsync(loginDTO.Email);
if (user is null)
{
return(Unauthorized());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (result.Succeeded)
{
return(Ok(new UserDTO
{
DisplayName = user.DisplayName,
UserName = user.UserName,
Token = _tokenService.CreateToken(user),
}));
}
return(Unauthorized());
}
public async Task <ActionResult <UserDto> > Login(LoginDTO loginDto)
{
if (loginDto.Username == null)
{
return(Unauthorized("Missing Username!"));
}
if (loginDto.Password == null)
{
return(Unauthorized("Missing Password!"));
}
var user = await _userManager.Users
.Include(p => p.Photos)
.SingleOrDefaultAsync(x => x.UserName == loginDto.Username.ToLower());
if (user == null)
{
return(Unauthorized("Username not Found"));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDto.Password, false);
if (result == Microsoft.AspNetCore.Identity.SignInResult.Failed)
{
return(Unauthorized("Invalid Password."));
}
else if (result == Microsoft.AspNetCore.Identity.SignInResult.NotAllowed)
{
return(Unauthorized("User cannot sign in without a confirmed email."));
}
return(new UserDto
{
Username = user.UserName,
Token = await _tokenService.CreateToken(user),
PhotoUrl = user.Photos.FirstOrDefault(a => a.IsMain == true)?.Url,
KnownAs = user.KnownAs,
Gender = user.Gender
});
}
public async Task <IActionResult> Login(LoginDTO model)
{
if (model is null)
{
_logger.LogError("LoginDTO object send from client is null");
return(BadRequest("LoginDTO object is null"));
}
var result = await _userService.LogIn(model);
if (!result.Success)
{
_logger.LogError($"User with email {model.Email} didn't successfully log.");
return(Ok(result));
//return BadRequest(result.Message);
}
_logger.LogInfo($"User with {model.Email} has successfully logged.");
return(Ok(result));
}
public async Task <IActionResult> Login(LoginDTO dto)
{
try
{
if (string.IsNullOrEmpty(dto.Email) || string.IsNullOrEmpty(dto.Password))
{
return(APIResponseCreator.GetResponse(ResponseCode.FAILED_CODE, "Please provide username and password.", dto.Email, System.Net.HttpStatusCode.OK));
}
var result = await _signInManager.PasswordSignInAsync(dto.Email, dto.Password, dto.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
return(APIResponseCreator.GetResponse(ResponseCode.SUCCESS_CODE, "Success", null, System.Net.HttpStatusCode.OK));
}
return(APIResponseCreator.GetResponse(ResponseCode.FAILED_CODE, result.ToString(), dto.Email, System.Net.HttpStatusCode.OK));
}
catch (Exception ex)
{
return(APIResponseCreator.GetResponse(ResponseCode.FAILED_CODE, ex.ToString(), null, System.Net.HttpStatusCode.OK));
}
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _userManager.FindByEmailAsync(loginDTO.Email);
if (user == null)
{
return(Unauthorized(new ApiResponse(401)));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (!result.Succeeded)
{
return(Unauthorized(new ApiResponse(401)));
}
return(new UserDTO {
Email = user.Email,
Token = _tokenService.CreateToken(user),
DisplayName = user.DispayName
});
}
public async Task<ActionResult<UserDto>> Login(LoginDTO loginDTO)
{
var user = await _context.Users.SingleOrDefaultAsync(
x => x.UserName == loginDTO.Username
);
if (user == null)
return Unauthorized("Invalid username");
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDTO.Password));
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != user.PasswordHash[i])
return Unauthorized("Invalid password");
}
return new UserDto
{
Username= user.UserName,
Token = _tokenService.CreateToken(user)
};
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _context.Users
.Include(p => p.Photos)
.SingleOrDefaultAsync(x => x.UserName == loginDTO.Username);
if (user == null)
{
return(Unauthorized("Invalid Username"));
}
using var hmac = new HMACSHA512(user.PasswordSalt); // when we create we create new instance of this class the default ctor will generate a random
// key , but during login we need to match the salted password with db,
// solution to this problem is an overload ctor which takes a key as byte[]
// and this key will generate the same salted hash password that was generate during registration for that user
// because this will use the same secret key.
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDTO.Password));
// point is that if input password is same as during reigtration then it will create same hashcode
// for computedHash and we can compare the hascode of stored password from database if it matches then user is Valid
//since out computeHash/ salted password is byte[] we need to loop over
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != user.PasswordHash[i])
{
return(Unauthorized("Invalid User"));
}
}
return(new UserDTO
{
Username = user.UserName,
Token = _tokenService.CreateToken(user),
PhotoUrl = user.Photos.FirstOrDefault(x => x.IsMain)?.Url,
KnownAs = user.KnownAs,
Gender = user.Gender
}); // After adding token things
}
public async Task <ActionResult> Login([FromBody] LoginDTO login)
{
var user = await userManager.FindByEmailAsync(login.Email);
if (user == null)
{
return(Unauthorized(new ApiResponse(401)));
}
var passwordCheck = await signInManager.CheckPasswordSignInAsync(user, login.Password, false);
if (!passwordCheck.Succeeded)
{
return(Unauthorized(new ApiResponse(401)));
}
var result = mapper.Map <UserDTO>(user);
result.Token = tokenService.CreateToken(user);
return(Ok(result));
}
public async Task <ActionResult <AppUser> > Login(LoginDTO loginDTO)
{
var user = await _context.Users.SingleOrDefaultAsync(x => x.userName == loginDTO.userName);
if (user == null)
{
return(Unauthorized("Invalid Username"));
}
if (loginDTO.Password != user.Password)
{
return(Unauthorized("Wrong password"));
}
// Send Email
var sender = new SmtpSender(() => new SmtpClient("email-smtp.us-east-2.amazonaws.com", 587)
{
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
Credentials = new NetworkCredential("AKIA3OZN4OEO7JODVWHV", "BJaigG9XlMHs0RhdXpE7OAoeRocssOts4aHp1Xh9kXoN")
//DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
//PickupDirectoryLocation = @"C:\Demos"
});
string rand_string = RandomString(8);
var body_email = "This is your verification number " + rand_string + " . Please paste this text to the ecommerce website. ";
Email.DefaultSender = sender;
var email = await Email
.From("*****@*****.**")
.To(user.Email, user.Name)
.Subject("Your Login Code !")
.Body(body_email)
.SendAsync();
user.MailCode = rand_string;
await _context.SaveChangesAsync();
return(user);
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO dto)
{
var user = await context.Users.SingleOrDefaultAsync(user => user.UserName == dto.Username);
if (user == null)
{
return(Unauthorized("Invalid Username"));
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(dto.Password));
for (int i = 0; i < hash.Length; i++)
{
if (hash[i] != user.PasswordHash[i])
{
return(Unauthorized("Wrong Password"));
}
}
return(new UserDTO {
Username = user.UserName,
Token = this.tokenService.CreateToken(user)
});
}
public async Task <object> Login([FromBody] LoginDTO login)
{
if (!ModelState.IsValid || login == null)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.FindByLogin(login);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
catch (ArgumentException ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _userManager.Users
.Include(p => p.Photos)
.SingleOrDefaultAsync(u => u.UserName == loginDTO.Username.ToLower());
if (user == null)
{
return(Unauthorized("Invalid username"));
}
var result = await _signInManager
.CheckPasswordSignInAsync(user, loginDTO.Password, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
// using var hmac = new HMACSHA512(user.PasswordSalt);
// var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDTO.Password));
// for (int i = 0; i < computedHash.Length; i++)
// {
// if (computedHash[i] != user.PasswordHash[i]) return Unauthorized("Invalid password");
// }
return(new UserDTO
{
UserName = user.UserName,
Token = await _tokenService.CreateToken(user),
PhotoUrl = user.Photos.FirstOrDefault(x => x.IsMain)?.Url,
KnownAs = user.KnownAs,
Gender = user.Gender
});
}
public async Task <ActionResult <AppUser> > Login(LoginDTO loginDTo)
{
AppUser user = await __context.MyProperty.SingleOrDefaultAsync(x => x.UserName == loginDTo.Username.ToLower());
if (user == null)
{
return(Unauthorized("invalid username"));
}
using HMAC hMAC = new HMACSHA512(user.PasswordSalt);
var Computedpassword = hMAC.ComputeHash(Encoding.UTF8.GetBytes(loginDTo.Password));
for (int i = 0; i < Computedpassword.Length; i++)
{
if (Computedpassword[i] != user.PasswordHash[i])
{
return(Unauthorized("Wrong password"));
}
}
return(user);
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO loginDTO)
{
var user = await _context.Users
.SingleOrDefaultAsync(u => u.UserName == loginDTO.UserName.ToLower());
if (user == null)
{
return(Unauthorized("Invalid Credentials"));
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDTO.Password));
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != user.PasswordHash[i])
{
return(Unauthorized("Invalid Password"));
}
}
return(new UserDTO {
UserName = user.UserName,
Token = _tokenService.CreateToken(user)
});
}
public async Task <ActionResult <UserDto> > Login(LoginDTO loginDto)
{
var user = await _userManager.FindByEmailAsync(loginDto.Email);
if (user == null)
{
return(Unauthorized(new APIResponse(401)));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDto.Password, false);
if (!result.Succeeded)
{
//We don't want to give any hint whether password is correct
return(Unauthorized(new APIResponse(401)));
}
return(new UserDto
{
Email = user.Email,
Token = _tokenService.CreateToken(user),
DisplayName = user.DisplayName
});
}
public async Task <ActionResult <UserDTO> > Login(LoginDTO login)
{
var user = await _Context.Users.SingleAsync(x => x.UserName == login.Username);
if (user is null)
{
return(Unauthorized("Usuario Invalido"));
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(login.Password));
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != user.PasswordHash[i])
{
return(Unauthorized("Password Invalido"));
}
}
return(new UserDTO
{
UserName = login.Username,
Token = _TokenServices.CreateToken(user)
});
}
