public virtual async Task <SignInResult> PasswordSignInAsync(TUser user, string password,
bool isPersistent, bool shouldLockout, CancellationToken cancellationToken = default(CancellationToken))
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var error = await PreSignInCheck(user, cancellationToken);
if (error != null)
{
return(await LogResultAsync(error, user));
}
if (await IsLockedOut(user, cancellationToken))
{
return(await LogResultAsync(SignInResult.LockedOut, user));
}
if (await UserManager.CheckPasswordAsync(user, password, cancellationToken))
{
await ResetLockout(user, cancellationToken);
return(await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken), user));
}
if (UserManager.SupportsUserLockout && shouldLockout)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user, cancellationToken);
if (await UserManager.IsLockedOutAsync(user, cancellationToken))
{
return(await LogResultAsync(SignInResult.LockedOut, user));
}
}
return(await LogResultAsync(SignInResult.Failed, user));
}
public virtual async Task <SignInStatus> PasswordSignInAsync(TUser user, string password,
bool isPersistent, bool shouldLockout, CancellationToken cancellationToken = default(CancellationToken))
{
var error = await PreSignInCheck(user, cancellationToken);
if (error != null)
{
return(error.Value);
}
if (await UserManager.CheckPasswordAsync(user, password, cancellationToken))
{
await ResetLockout(user, cancellationToken);
return(await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken));
}
if (UserManager.SupportsUserLockout && shouldLockout)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user, cancellationToken);
if (await UserManager.IsLockedOutAsync(user, cancellationToken))
{
return(SignInStatus.LockedOut);
}
}
return(SignInStatus.Failure);
}
public virtual async Task <SignInStatus> PasswordSignInAsync(string userName, string password,
bool isPersistent, bool shouldLockout)
{
var user = await UserManager.FindByNameAsync(userName);
if (user == null)
{
return(SignInStatus.Failure);
}
if (UserManager.SupportsUserLockout && await UserManager.IsLockedOutAsync(user))
{
return(SignInStatus.LockedOut);
}
if (await UserManager.CheckPasswordAsync(user, password))
{
return(await SignInOrTwoFactor(user, isPersistent));
}
if (UserManager.SupportsUserLockout && shouldLockout)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user);
if (await UserManager.IsLockedOutAsync(user))
{
return(SignInStatus.LockedOut);
}
}
return(SignInStatus.Failure);
}
public virtual async Task <SignInStatus> TwoFactorSignInAsync(string provider, string code, bool isPersistent)
{
var userId = await AuthenticationManager.RetrieveUserId();
if (userId == null)
{
return(SignInStatus.Failure);
}
var user = await UserManager.FindByIdAsync(userId);
if (user == null)
{
return(SignInStatus.Failure);
}
if (await UserManager.IsLockedOutAsync(user))
{
return(SignInStatus.LockedOut);
}
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code))
{
// When token is verified correctly, clear the access failed count used for lockout
await UserManager.ResetAccessFailedCountAsync(user);
await SignInAsync(user, isPersistent);
return(SignInStatus.Success);
}
// If the token is incorrect, record the failure which also may cause the user to be locked out
await UserManager.AccessFailedAsync(user);
return(SignInStatus.Failure);
}
/// <summary>
/// Increments the access failed count for the user
/// </summary>
/// <param name="manager"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static IdentityResult AccessFailed <TUser, TKey>(this UserManager <TUser, TKey> manager, TKey userId)
where TKey : IEquatable <TKey>
where TUser : class, IUser <TKey>
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
return(AsyncHelper.RunSync(() => manager.AccessFailedAsync(userId)));
}
public virtual async Task <SignInResult> TwoFactorSignInAsync(string provider, string code, bool isPersistent,
bool rememberClient)
{
var twoFactorInfo = await RetrieveTwoFactorInfoAsync();
if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{
return(SignInResult.Failed);
}
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId);
if (user == null)
{
return(SignInResult.Failed);
}
using (await BeginLoggingScopeAsync(user))
{
var error = await PreSignInCheck(user);
if (error != null)
{
return(Logger.Log(error));
}
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code))
{
// When token is verified correctly, clear the access failed count used for lockout
await ResetLockout(user);
// Cleanup external cookie
if (twoFactorInfo.LoginProvider != null)
{
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationScheme);
}
await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider);
if (rememberClient)
{
await RememberTwoFactorClientAsync(user);
}
await UserManager.ResetAccessFailedCountAsync(user);
await SignInAsync(user, isPersistent);
return(Logger.Log(SignInResult.Success));
}
// If the token is incorrect, record the failure which also may cause the user to be locked out
await UserManager.AccessFailedAsync(user);
return(Logger.Log(SignInResult.Failed));
}
}
public virtual async Task <SignInStatus> TwoFactorSignInAsync(string provider, string code, bool isPersistent,
bool rememberClient, CancellationToken cancellationToken = default(CancellationToken))
{
var twoFactorInfo = await RetrieveTwoFactorInfoAsync(cancellationToken);
if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{
return(SignInStatus.Failure);
}
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId, cancellationToken);
if (user == null)
{
return(SignInStatus.Failure);
}
var error = await PreSignInCheck(user, cancellationToken);
if (error != null)
{
return(error.Value);
}
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code, cancellationToken))
{
// When token is verified correctly, clear the access failed count used for lockout
await ResetLockout(user, cancellationToken);
// Cleanup external cookie
if (twoFactorInfo.LoginProvider != null)
{
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType);
}
await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider, cancellationToken);
if (rememberClient)
{
await RememberTwoFactorClientAsync(user, cancellationToken);
}
return(SignInStatus.Success);
}
// If the token is incorrect, record the failure which also may cause the user to be locked out
await UserManager.AccessFailedAsync(user, cancellationToken);
return(SignInStatus.Failure);
}
public virtual async Task <SignInResult> PasswordSignInAsync(TUser user, string password,
bool isPersistent, bool shouldLockout)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
using (await BeginLoggingScopeAsync(user))
{
var error = await PreSignInCheck(user);
if (error != null)
{
return(Logger.Log(error));
}
if (await IsLockedOut(user))
{
return(Logger.Log(SignInResult.LockedOut));
}
if (await UserManager.CheckPasswordAsync(user, password))
{
await ResetLockout(user);
return(Logger.Log(await SignInOrTwoFactorAsync(user, isPersistent)));
}
if (UserManager.SupportsUserLockout && shouldLockout)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user);
if (await UserManager.IsLockedOutAsync(user))
{
return(Logger.Log(SignInResult.LockedOut));
}
}
return(Logger.Log(SignInResult.Failed));
}
}
/// <summary>
/// Attempts to sign in the specified <paramref name="user"/> and <paramref name="password"/> combination
/// as an asynchronous operation.
/// </summary>
/// <param name="user">The user to sign in.</param>
/// <param name="password">The password to attempt to sign in with.</param>
/// <param name="isPersistent">Flag indicating whether the sign-in cookie should persist after the browser is closed.</param>
/// <param name="lockoutOnFailure">Flag indicating if the user account should be locked if the sign in fails.</param>
/// <returns>The task object representing the asynchronous operation containing the <see name="SignInResult"/>
/// for the sign-in attempt.</returns>
public virtual async Task <SignInResult> PasswordSignInAsync(TUser user, string password,
bool isPersistent, bool lockoutOnFailure)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var error = await PreSignInCheck(user);
if (error != null)
{
return(error);
}
if (await IsLockedOut(user))
{
return(await LockedOut(user));
}
if (await UserManager.CheckPasswordAsync(user, password))
{
await ResetLockout(user);
return(await SignInOrTwoFactorAsync(user, isPersistent));
}
Logger.LogWarning("User {userId} failed to provide the correct password.", await UserManager.GetUserIdAsync(user));
if (UserManager.SupportsUserLockout && lockoutOnFailure)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user);
if (await UserManager.IsLockedOutAsync(user))
{
return(await LockedOut(user));
}
}
return(SignInResult.Failed);
}