예제 #1
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");

            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
                var result = await _signInManager.PasswordSignInAsync(Input.Username, Input.Password, Input.RememberMe, lockoutOnFailure : false);

                if (result.Succeeded)
                {
                    _logger.LogInformation("User logged in.");
                    return(LocalRedirect(returnUrl));
                }
                if (result.RequiresTwoFactor)
                {
                    return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe }));
                }
                if (result.IsLockedOut)
                {
                    _logger.LogWarning("User account locked out.");
                    return(RedirectToPage("./Lockout"));
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return(Page());
                }
            }

            // If we got this far, something failed, redisplay form
            return(Page());
        }
예제 #2
0
        public async Task <IActionResult> Index(LoginViewModel model, string returnUrl = null)
        {
            ViewData[_RET_URL] = returnUrl;

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

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

            if (user == null)
            {
                ModelState.AddModelError("", AppErrorText.LoginInvallidUserPass);
                return(View(model));
            }

            if (user.Status != UserStatus.Enabled)
            {
                ModelState.AddModelError("", AppErrorText.LoginUserDisabled);
                return(View(model));
            }

            if (_appSettings.Value.EnableEmailConfirmation &&
                !await _userManager.IsEmailConfirmedAsync(user))
            {
                ModelState.AddModelError("", AppErrorText.LoginEmailNotVerified);
                return(View(model));
            }

            var result = await _signInManager.PasswordSignInAsync(model.Username,
                                                                  model.Password,
                                                                  model.RememberMe,
                                                                  lockoutOnFailure : true);

            await _userManager.AddClaimAsync(user, new Claim(
                                                 "WebsiteId", _websiteInfo.Id.ToString()
                                                 ));

            if (result.Succeeded)
            {
                _logger.LogInformation($"{model.Username} logged in on ${_dateService.UtcNow()}");

                if (Url.IsLocalUrl(returnUrl))
                {
                    return(Redirect(returnUrl));
                }

                return(RedirectToAction(
                           "Index",
                           "Home",
                           new { area = AreaNames.AdminArea }
                           ));
            }

            if (result.RequiresTwoFactor)
            {
            }

            if (result.IsLockedOut)
            {
                _logger.LogWarning($"{model.Username} is locked-out.");
                ModelState.AddModelError("", AppErrorText.LoginLockedOut);
                return(View(model));
            }

            if (result.IsNotAllowed)
            {
                ModelState.AddModelError("", AppErrorText.LoginIsNotAllowed);
                return(View(model));
            }

            ModelState.AddModelError(string.Empty, AppErrorText.LoginNotValid);

            return(View(model));
        }