public async Task <Guid> GetToken()
        {
            var token = _tokenProvider.Create();

            await _bookCreator.CreateDefaultBooks(token);

            return(token);
        }
        public async Task <IActionResult> Login([FromBody] LoginViewModel model)
        {
            var user = await _userService.SignInAsync(model.EmailAddress, model.Password);

            if (user != null)
            {
                Guid tenantId = user.TenantId;
                Guid userId   = user.Id;

                return(Ok(_tokenProvider.Create(tenantId, userId)));
            }

            return(Unauthorized());
        }
Exemple #3
0
            public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
            {
                if (await _context.Accounts.AnyAsync(x => x.Email == request.Email, cancellationToken))
                {
                    throw new RestException(HttpStatusCode.Conflict, ResourceConstant.AlreadyUsedEmail);
                }

                var account = request.ToAccount(_passwordHasher);

                _context.Accounts.Add(account);

                await _context.SaveChangesAsync(cancellationToken);

                return(new Response
                {
                    Token = _tokenProvider.Create(account)
                });
            }
Exemple #4
0
            public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
            {
                var account = await _context.Accounts.Where(x => x.Email == request.Email).SingleOrDefaultAsync(cancellationToken);

                if (account == null)
                {
                    throw new RestException(HttpStatusCode.Unauthorized, ResourceConstant.Unauthorized);
                }

                if (!_passwordHasher.VerifyHashedPassword(request.Password, account.PasswordHash))
                {
                    throw new RestException(HttpStatusCode.Unauthorized, ResourceConstant.Unauthorized);
                }

                return(new Response
                {
                    Token = _tokenProvider.Create(account)
                });
            }
        public async Task <RequestResult <LoginResultViewModel> > Login(LoginViewModel model)
        {
            var user = await _userManager.FindByNameAsync(model.UserName);

            if (user == null)
            {
                return(RequestResult <LoginResultViewModel> .Failed("Неверный логин или пароль"));
            }

            if (await _userManager.IsLockedOutAsync(user))
            {
                return(RequestResult <LoginResultViewModel> .Failed("Пользователь заблокирован"));
            }

            var isPasswordValid = await _userManager.CheckPasswordAsync(user, model.Password);

            if (!isPasswordValid)
            {
                await _userManager.AccessFailedAsync(user);

                return(RequestResult <LoginResultViewModel> .Failed("Неверный логин или пароль"));
            }

            var resetResult = await _userManager.ResetAccessFailedCountAsync(user);

            if (!resetResult.Succeeded)
            {
                return(RequestResult <LoginResultViewModel> .Failed(resetResult.Errors.First().Description));
            }

            return(RequestResult <LoginResultViewModel> .Success(new LoginResultViewModel
            {
                AccessToken = await _tokenProvider.Create(user),
                UserInfo = new UserInfoViewModel(user)
            }));
        }