Beispiel #1
0
        public async Task <UserTokenModel> LoginAsync(LoginModel criterias)
        {
            var result = await _loginManager.PasswordSignInAsync(criterias.Username, criterias.Password, true, true);

            if (!result.Succeeded)
            {
                throw new UnauthorizedAccessException();
            }

            var user = await _userManager.FindByNameAsync(criterias.Username);

            user.UserIdentityId = await _userManager.EncryptUserIdAsync(user.Id);

            var accessToken = _jwtHelper.GenerateJwtToken(user);

            var refreshToken = await _userManager.GenerateUserTokenAsync(user, ServiceProvidersNameConst.CAMINO_API_AUTH, IdentitySettings.AUTHENTICATION_REFRESH_TOKEN_PURPOSE);

            await _userManager.SetAuthenticationTokenAsync(user, ServiceProvidersNameConst.CAMINO_API_AUTH, IdentitySettings.AUTHENTICATION_REFRESH_TOKEN_PURPOSE, refreshToken);

            AddRefreshTokenToCookie(refreshToken);
            return(new UserTokenModel(true)
            {
                AuthenticationToken = accessToken,
                RefreshToken = refreshToken,
                RefreshTokenExpiryTime = DateTime.Now.AddHours(_jwtConfigOptions.RefreshTokenHourExpires)
            });
        }
Beispiel #2
0
        public async Task <TokenDto> Authenticate(LoginData data)
        {
            var user = await _context
                       .Users
                       .Include(e => e.RefreshTokens)
                       .FirstOrDefaultAsync(e => e.Username == data.Username && e.Active)
                       ?? throw new NotFoundException($"No user for username {data.Username}");

            if (!VerifyPasswordHash(data.Password, user.PasswordHash, user.PasswordSalt))
            {
                throw new ArgumentException("Invalid password.");
            }

            var token = _jwtHelper.GenerateJwtToken(user);

            var referenceTime = _dateTime.Now;
            var refreshToken  = user.RefreshTokens
                                .FirstOrDefault(e => e.Revoked == null &&
                                                referenceTime < e.Expires);

            if (refreshToken == null)
            {
                refreshToken = CreateRefreshToken();
                user.RefreshTokens.Add(refreshToken);

                await _context.SaveChangesAsync();
            }

            token.RefreshToken           = refreshToken.Token;
            token.RefreshTokenValidUntil = refreshToken.Expires;

            return(token);
        }
Beispiel #3
0
        public async Task <Response> Login(LoginRequest request)
        {
            var result = await _signInManager.PasswordSignInAsync(request.UserName, request.Password, true, false);

            if (!result.Succeeded)
            {
                return(new ErrorResponse("Ksywa lub hasło jest błędne!"));
            }

            var user = Context.Users.FirstOrDefault(i => i.UserName == request.UserName);

            if (user.IsBanned)
            {
                return(new ErrorResponse("Konto zostało zbanowane!"));
            }

            if (user.IsDeleted)
            {
                return(new ErrorResponse("Konto zostało usunięte!"));
            }

            var token = _jwtHelper.GenerateJwtToken(request.UserName);

            if (token == null)
            {
                return(new ErrorResponse("Nie znaleziono użytkownika"));
            }

            AddLog($"{request.UserName} zalogował się na konto");
            return(new SuccessResponse <JwtToken>(token));
        }
        public async Task <LoginResponse> Login(LoginRequest request)
        {
            var user = await _unitOfWork.Repository.GetSingle(x =>
                                                              x.Username == request.Username);

            if (user != null)
            {
                if (HashHelper.ValidateHash(request.Password, user.PasswordHash))
                {
                    var token = _jwtHelper.GenerateJwtToken(new AppUser(user));
                    return(new LoginResponse(user, token));
                }
            }

            throw new AppException("incorrect username or password");
        }
Beispiel #5
0
        public async Task <ServiceResponse <AuthenticateViewModel> > Register(RegisterRequest request)
        {
            var isEmailValid = EmailValidator.IsEmailValid(request.Email);

            if (!isEmailValid)
            {
                return(ServiceResponse <AuthenticateViewModel> .Error("Invalid email"));
            }

            var player = await _context.Players.FirstOrDefaultAsync(
                x => x.Email == request.Email);

            if (player != null)
            {
                return(ServiceResponse <AuthenticateViewModel> .Error("Email already exist"));
            }

            var(isPasswordValid, passwordMessage) = _passwordValidator.ValidateAsync(request.Password);

            if (!isPasswordValid)
            {
                return(ServiceResponse <AuthenticateViewModel> .Error(passwordMessage));
            }

            var hashedPassword =
                _passwordHasher.HashPassword(player, request.Password);


            var refreshToken = _jwtHelper.GenerateRefreshToken();

            var newPlayer = new Player
            {
                Email        = request.Email,
                PasswordHash = hashedPassword,
                Nick         = request.Nick,
                RefreshToken = refreshToken,
            };

            await _context.Players.AddAsync(newPlayer);

            await _context.SaveChangesAsync();

            var accessToken = _jwtHelper.GenerateJwtToken(newPlayer);

            return(ServiceResponse <AuthenticateViewModel> .Ok(
                       new AuthenticateViewModel(accessToken, refreshToken.Token)));
        }
        private DtoUserResponse MapUserToDtoUserResponse(User user)
        {
            //ony for user, not for admin
            var dtoUser = new DtoUserResponse
            {
                Id       = user.Id,
                Gender   = user.Gender,
                Name     = user.Name,
                BirthDay = user.BirthDay,
                SkinType = user.SkinType,
                Email    = user.Email,
                Token    = _jwtHelper.GenerateJwtToken(user),
            };

            return(dtoUser);
        }
        public async Task <IActionResult> LoginAsync(UserCredentials model)
        {
            var user = await _signInManager.UserManager.FindByNameAsync(model.UserName);

            if (user == null)
            {
                return(NotFound(new { error = "Пользователь не найден." }));
            }

            SignInResult signInResult = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false);

            if (signInResult.Succeeded)
            {
                string token = _jwtHelper.GenerateJwtToken(user);
                return(new JsonResult(new LoginResult {
                    Token = token
                }));
            }
            return(BadRequest(new { error = "Неверный пароль." }));
        }