public async Task <ActionResult> Login(LoginViewModel loginViewModel, string returnUrl)
{
if (this.ModelState.IsValid)
{
var signInStatus = await this.userIdentityApplicationService.SignInWithUsernameAndPasswordAsync(loginViewModel.Email, loginViewModel.Password, loginViewModel.RememberBrowserCookie, shouldLockout : false);
switch (signInStatus)
{
case SignInStatus.Success:
return(this.RedirectToLocalUrl(returnUrl));
case SignInStatus.LockedOut:
var lockoutViewModel = new LockoutViewModel(this.userIdentityProvider);
return(this.View("Lockout", lockoutViewModel));
case SignInStatus.RequiresVerification:
return(this.RedirectToAction(nameof(this.SendCode), "Account", new { ReturnUrl = returnUrl, loginViewModel.RememberBrowserCookie }));
case SignInStatus.Failure:
default:
this.ModelState.AddModelError(string.Empty, Resource.AccountControllerLoginErrorMessage);
return(this.View(loginViewModel));
}
}
return(this.View(loginViewModel));
}
public async Task <IActionResult> Lockout(string id, [Bind("Id, TermId, LockoutEnd")] LockoutViewModel model)
{
if (id == null || id != model.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(BadRequest());
}
user.LockoutEnd = model.LockoutEnd;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
await _userManager.UpdateSecurityStampAsync(user);
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult> VerifyCode(VerifyCodeViewModel verifyCodeViewModel)
{
if (this.ModelState.IsValid)
{
var signInStatus = await this.userIdentityApplicationService.SignInWithTwoFactorAuthenticationAsync(verifyCodeViewModel.ProviderKey, verifyCodeViewModel.Code, verifyCodeViewModel.RememberBrowserCookie, verifyCodeViewModel.RememberBrowser);
switch (signInStatus)
{
case SignInStatus.Success:
return(this.RedirectToLocalUrl(verifyCodeViewModel.ReturnUrl));
case SignInStatus.LockedOut:
var lockoutViewModel = new LockoutViewModel(this.userIdentityProvider);
return(this.View("Lockout", lockoutViewModel));
case SignInStatus.Failure:
default:
this.ModelState.AddModelError(string.Empty, Resource.AccountControllerVerifyCodeErrorMessage);
return(this.View(verifyCodeViewModel));
}
}
return(this.View(verifyCodeViewModel));
}
public async Task <IActionResult> Lockout(string id)
{
var user = await this.userManager.FindByIdAsync(id);
var lockoutEnd = user.LockoutEnd.Value.DateTime;
var lockoutModel = new LockoutViewModel {
LockoutEnd = lockoutEnd
};
return(this.View(lockoutModel));
}
public async Task <ActionResult> Lockout(string userName)
{
var user = await UserManager.FindByNameAsync(userName);
var date = (await UserManager.GetLockoutEndDateAsync(user.Id)).DateTime;
var model = new LockoutViewModel
{
UserName = user.UserName,
EndLockoutDate = date
};
return(View(model));
}
public async Task <ActionResult> ExternalLoginCallback(string returnUrl)
{
var userExternalLogin = await this.userIdentityApplicationService.GetUserExternalLoginAsync();
if (userExternalLogin != null)
{
var signInStatus = await this.userIdentityApplicationService.SignInWithUserExternalLoginAsync(userExternalLogin, false);
switch (signInStatus)
{
case SignInStatus.Success:
return(this.RedirectToLocalUrl(returnUrl));
case SignInStatus.LockedOut:
var lockoutViewModel = new LockoutViewModel(this.userIdentityProvider);
return(this.View("Lockout", lockoutViewModel));
case SignInStatus.RequiresVerification:
return(this.RedirectToAction(nameof(this.SendCode), "Account", new { ReturnUrl = returnUrl, RememberBrowserCookie = false }));
case SignInStatus.Failure:
default:
// If the user does not have an account, then prompt the user to create an account
var externalLoginConfirmationViewModel = new ExternalLoginConfirmationViewModel(this.userIdentityProvider)
{
Email = userExternalLogin.Email,
ReturnUrl = returnUrl,
LoginProvider = userExternalLogin.LinkedLogin.LoginProvider
};
return(this.View(nameof(this.ExternalLoginConfirmation), externalLoginConfirmationViewModel));
}
}
return(this.RedirectToAction(nameof(this.Login), "Account"));
}
public async Task <IActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
// Check if we are in the context of an authorization request
AuthorizationRequest context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, true, lockoutOnFailure : true);
if (result.Succeeded)
{
// Set language cookie
ApplicationUser user = await _userManager.FindByEmailAsync(model.Email);
await _events.RaiseAsync(new UserLoginSuccessEvent(user.UserName, user.Id.ToString(), user.UserName, clientId : context?.Client.ClientId));
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(user.Language)),
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1),
IsEssential = true,
Path = "/",
HttpOnly = false,
SameSite = SameSiteMode.Strict
}
);
if (model.ReturnUrl != null)
{
return(RedirectToLocal(model.ReturnUrl));
}
return(RedirectToAction(nameof(HomeController.Overview), "Home"));
}
if (result.IsNotAllowed)
{
await _events.RaiseAsync(new UserLoginFailureEvent(model.Email, "Email confirmation required", clientId : context?.Client.ClientId));
return(RedirectToAction(nameof(AccountController.Login), new { model.ReturnUrl, alert = LoginAlert.EmailConfirmationRequired }));
}
if (result.IsLockedOut)
{
await _events.RaiseAsync(new UserLoginFailureEvent(model.Email, "Locked out", clientId : context?.Client.ClientId));
ApplicationUser user = await _userManager.FindByEmailAsync(model.Email);
var lockoutEnd = (DateTimeOffset)await _userManager.GetLockoutEndDateAsync(user);
var lockoutViewModel = new LockoutViewModel
{
LockoutEndMinutes = (int)(lockoutEnd.UtcDateTime - DateTime.UtcNow).TotalMinutes + 1
};
return(View("Lockout", lockoutViewModel));
}
else
{
await _events.RaiseAsync(new UserLoginFailureEvent(model.Email, "Invalid credentials", clientId : context?.Client.ClientId));
ModelState.AddModelError(string.Empty, _localizer["InvalidLoginAttempt"]);
return(View(nameof(AccountController.Login), model));
}
}
return(View(nameof(AccountController.Login), model));
}
