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 computeHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(loginDto.Password));

            for (int i = 0; i < computeHash.Length; i++)
            {
                if (computeHash[i] != user.PasswodHash[i])
                {
                    return(Unauthorized("Invalid Password"));
                }
            }
            return(new UserDto
            {
                Username = user.UserName,
                Token = _tokenservice.CreateToken(user)
            });
        }
Exemple #2
0
        public async Task <ActionResult <UserDTo> > Login(LoginDTo loginDTo)
        {
            var user = await _userManager.Users
                       .Include(p => p.Photos)
                       .SingleOrDefaultAsync(x => x.UserName == loginDTo.Username.ToLower());

            if (user == null)
            {
                return(Unauthorized("Username is not valid."));
            }

            var result = await _signInManager.CheckPasswordSignInAsync(user, loginDTo.Password, false);

            if (!result.Succeeded)
            {
                return(Unauthorized());
            }

            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 <UserDto> > Login(LoginDTo loginDTo)
      {
          var user = await _userManager.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());
      }
Exemple #4
0
        public async Task <ActionResult <UserToken> > Login([FromBody] LoginDTo modelLogin)
        {
            var user = await _userManager.FindByEmailAsync(modelLogin.email);

            if (user == null)
            {
                return(NotFound());
            }

            var result = await _signInManager.PasswordSignInAsync(user, modelLogin.password, false, false);

            if (!result.Succeeded)
            {
                return(BadRequest("Invalid Login"));
            }

            return(GenerateJwtToken(modelLogin.email, user));
        }
Exemple #5
0
        public async Task <ActionResult <UserToken> > ForgotPassWord([FromBody] LoginDTo login)
        {
            var user = await _userManager.FindByEmailAsync(login.email);

            if (user == null)
            {
                return(NotFound());
            }

            var token = await _userManager.GeneratePasswordResetTokenAsync(user);

            var result = await _userManager.ResetPasswordAsync(user, token, login.password);

            if (!result.Succeeded)
            {
                return(BadRequest(result.Errors));
            }

            await _signInManager.PasswordSignInAsync(user, login.password, false, false);

            return(GenerateJwtToken(login.email, user));
        }