huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove CancellationToken from Manager APIs

This commit is contained in:
Hao Kung 2015-02-10 15:39:42 -08:00
parent 228995c84c
commit 597e2b3153
38 changed files with 556 additions and 818 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs
View File

@ -77,16 +77,14 @@ namespace Microsoft.AspNet.Identity
/// <param name="user">The user instance to create claims on.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for the tasks to complete.</param>
/// <returns>A <see cref="Task{TResult}"/> that represents the started task.</returns>
public virtual async Task<ClaimsIdentity> CreateAsync(
TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<ClaimsIdentity> CreateAsync(TUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var userId = await UserManager.GetUserIdAsync(user, cancellationToken);
var userName = await UserManager.GetUserNameAsync(user, cancellationToken);
var userId = await UserManager.GetUserIdAsync(user);
var userName = await UserManager.GetUserNameAsync(user);
var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType, Options.ClaimsIdentity.UserNameClaimType,
Options.ClaimsIdentity.RoleClaimType);
id.AddClaim(new Claim(Options.ClaimsIdentity.UserIdClaimType, userId));
@ -94,11 +92,11 @@ namespace Microsoft.AspNet.Identity
if (UserManager.SupportsUserSecurityStamp)
{
id.AddClaim(new Claim(Options.ClaimsIdentity.SecurityStampClaimType,
await UserManager.GetSecurityStampAsync(user, cancellationToken)));
await UserManager.GetSecurityStampAsync(user)));
}
if (UserManager.SupportsUserRole)
{
var roles = await UserManager.GetRolesAsync(user, cancellationToken);
var roles = await UserManager.GetRolesAsync(user);
foreach (var roleName in roles)
{
id.AddClaim(new Claim(Options.ClaimsIdentity.RoleClaimType, roleName, ClaimValueTypes.String));
@ -107,14 +105,14 @@ namespace Microsoft.AspNet.Identity
var role = await RoleManager.FindByNameAsync(roleName);
if (role != null)
{
id.AddClaims(await RoleManager.GetClaimsAsync(role, cancellationToken));
id.AddClaims(await RoleManager.GetClaimsAsync(role));
}
}
}
}
if (UserManager.SupportsUserClaim)
{
id.AddClaims(await UserManager.GetClaimsAsync(user, cancellationToken));
id.AddClaims(await UserManager.GetClaimsAsync(user));
}
return id;
}

18
src/Microsoft.AspNet.Identity/DataProtectionTokenProvider.cs
View File

@ -65,15 +65,14 @@ namespace Microsoft.AspNet.Identity
/// <param name="user">The <see cref="TUser"/> the token will be generated from.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for the tasks to complete.</param>
/// <returns>A <see cref="Task{TResult}"/> that contains the protected token.</returns>
public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var ms = new MemoryStream();
var userId = await manager.GetUserIdAsync(user, cancellationToken);
var userId = await manager.GetUserIdAsync(user);
using (var writer = ms.CreateWriter())
{
writer.Write(DateTimeOffset.UtcNow);
@ -97,10 +96,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token">The token to validate.</param>
/// <param name="manager">The <see cref="UserManager{TUser}"/> to retrieve user properties from.</param>
/// <param name="user">The <see cref="TUser"/> the token was generated for.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for the tasks to complete.</param>
/// <returns>A <see cref="Task{TResult}"/> that is true if the token is valid, otherwise false.</returns>
public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
{
try
{
@ -116,7 +113,7 @@ namespace Microsoft.AspNet.Identity
}
var userId = reader.ReadString();
var actualUserId = await manager.GetUserIdAsync(user, cancellationToken);
var actualUserId = await manager.GetUserIdAsync(user);
if (userId != actualUserId)
{
return false;
@ -155,8 +152,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user">The <see cref="TUser"/> the token was generated for.</param>
/// <returns>True if a token generated by this instance can be used as a Two Factor Authentication token, otherwise false.</returns>
/// <remarks>This method will always return false for instances of <see cref="DataProtectorTokenProvider{TUser}"/>.</remarks>
public virtual Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
{
return Task.FromResult(false);
}
@ -167,10 +163,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token">The token to generate notifications for..</param>
/// <param name="manager">The <see cref="UserManager{TUser}"/> to retrieve user properties from.</param>
/// <param name="user">The <see cref="TUser"/> the token was generated for.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for the tasks to complete.</param>
/// <returns>A <see cref="Task{TResult}"/> that represents the started task.</returns>
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
{
return Task.FromResult(0);
}

18
src/Microsoft.AspNet.Identity/EmailTokenProvider.cs
View File

@ -46,11 +46,10 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
{
var email = await manager.GetEmailAsync(user, cancellationToken);
return !string.IsNullOrWhiteSpace(email) && await manager.IsEmailConfirmedAsync(user, cancellationToken);
var email = await manager.GetEmailAsync(user);
return !string.IsNullOrWhiteSpace(email) && await manager.IsEmailConfirmedAsync(user);
}
/// <summary>
@ -61,9 +60,9 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <returns></returns>
public override async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager,
TUser user, CancellationToken cancellationToken = default(CancellationToken))
TUser user)
{
var email = await manager.GetEmailAsync(user, cancellationToken);
var email = await manager.GetEmailAsync(user);
return "Email:" + purpose + ":" + email;
}
@ -74,8 +73,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
@ -83,11 +81,11 @@ namespace Microsoft.AspNet.Identity
}
var msg = new IdentityMessage
{
Destination = await manager.GetEmailAsync(user, cancellationToken),
Destination = await manager.GetEmailAsync(user),
Subject = Options.Subject,
Body = string.Format(CultureInfo.CurrentCulture, Options.BodyFormat, token)
};
await manager.SendMessageAsync(Options.MessageProvider, msg, cancellationToken);
await manager.SendMessageAsync(Options.MessageProvider, msg);
}
}
}

3
src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs
View File

@ -19,8 +19,7 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="authenticationType"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<ClaimsIdentity> CreateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<ClaimsIdentity> CreateAsync(TUser user);
}
}

2
src/Microsoft.AspNet.Identity/IIdentityMessageProvider.cs
View File

@ -10,6 +10,6 @@ namespace Microsoft.AspNet.Identity
{
string Name { get; }
Task SendAsync(IdentityMessage message, CancellationToken cancellationToken = default(CancellationToken));
Task SendAsync(IdentityMessage message, CancellationToken cancellationToken);
}
}

3
src/Microsoft.AspNet.Identity/IPasswordValidator.cs
View File

@ -15,7 +15,6 @@ namespace Microsoft.AspNet.Identity
/// Validate the password for the user
/// </summary>
/// <returns></returns>
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password,
CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password);
}
}

23
src/Microsoft.AspNet.Identity/IRoleStore.cs
View File

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> CreateAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> CreateAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// Update a role
@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> UpdateAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> UpdateAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// DeleteAsync a role
@ -35,7 +35,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> DeleteAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> DeleteAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// Returns a role's id
@ -43,7 +43,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetRoleIdAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetRoleIdAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// Returns a role's name
@ -51,7 +51,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetRoleNameAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetRoleNameAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// Set a role's name
@ -60,8 +60,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetRoleNameAsync(TRole role, string roleName,
CancellationToken cancellationToken = default(CancellationToken));
Task SetRoleNameAsync(TRole role, string roleName, CancellationToken cancellationToken);
/// <summary>
/// Get a role's normalized name
@ -69,8 +68,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetNormalizedRoleNameAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetNormalizedRoleNameAsync(TRole role, CancellationToken cancellationToken);
/// <summary>
/// Set a role's normalized name
@ -79,8 +77,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetNormalizedRoleNameAsync(TRole role, string normalizedName,
CancellationToken cancellationToken = default(CancellationToken));
Task SetNormalizedRoleNameAsync(TRole role, string normalizedName, CancellationToken cancellationToken);
/// <summary>
@ -89,7 +86,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TRole> FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken));
Task<TRole> FindByIdAsync(string roleId, CancellationToken cancellationToken);
/// <summary>
/// Find a role by normalized name
@ -97,6 +94,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedRoleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TRole> FindByNameAsync(string normalizedRoleName, CancellationToken cancellationToken = default(CancellationToken));
Task<TRole> FindByNameAsync(string normalizedRoleName, CancellationToken cancellationToken);
}
}

4
src/Microsoft.AspNet.Identity/IRoleValidator.cs
View File

@ -17,9 +17,7 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="role"></param>
/// <param name="manager"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role,
CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role);
}
}

4
src/Microsoft.AspNet.Identity/ISecurityStampValidator.cs
View File

@ -2,7 +2,6 @@
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Security.Cookies;
@ -10,7 +9,6 @@ namespace Microsoft.AspNet.Identity
{
public interface ISecurityStampValidator
{
Task ValidateAsync(CookieValidateIdentityContext context, ClaimsIdentity identity,
CancellationToken cancellationToken = default(CancellationToken));
Task ValidateAsync(CookieValidateIdentityContext context, ClaimsIdentity identity);
}
}

12
src/Microsoft.AspNet.Identity/IUserClaimStore.cs
View File

@ -20,8 +20,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<Claim>> GetClaimsAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<IList<Claim>> GetClaimsAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Add a new user claim
@ -30,7 +29,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="claims"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken = default(CancellationToken));
Task AddClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken);
/// <summary>
/// Updates the give claim information with the given new claim information
@ -40,7 +39,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="newClaim"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task ReplaceClaimAsync(TUser user, Claim claim, Claim newClaim, CancellationToken cancellationToken = default(CancellationToken));
Task ReplaceClaimAsync(TUser user, Claim claim, Claim newClaim, CancellationToken cancellationToken);
/// <summary>
/// Remove a user claim
@ -49,8 +48,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="claims"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveClaimsAsync(TUser user, IEnumerable<Claim> claims,
CancellationToken cancellationToken = default(CancellationToken));
Task RemoveClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken);
/// <summary>
/// Get users having a specific claim
@ -58,6 +56,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="claim">Claim to look up</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<TUser>> GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken = default(CancellationToken));
Task<IList<TUser>> GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken);
}
}

18
src/Microsoft.AspNet.Identity/IUserEmailStore.cs
View File

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="email"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken = default(CancellationToken));
Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken);
/// <summary>
/// Get the user email
@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetEmailAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetEmailAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns true if the user email is confirmed
@ -35,8 +35,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetEmailConfirmedAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> GetEmailConfirmedAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Sets whether the user email is confirmed
@ -45,8 +44,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="confirmed"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetEmailConfirmedAsync(TUser user, bool confirmed,
CancellationToken cancellationToken = default(CancellationToken));
Task SetEmailConfirmedAsync(TUser user, bool confirmed, CancellationToken cancellationToken);
/// <summary>
/// Returns the user associated with this email
@ -54,7 +52,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedEmail"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken = default(CancellationToken));
Task<TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken);
/// <summary>
/// Returns the normalized email
@ -62,7 +60,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetNormalizedEmailAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetNormalizedEmailAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Set the normalized email
@ -71,8 +69,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedEmail"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetNormalizedEmailAsync(TUser user, string normalizedEmail,
CancellationToken cancellationToken = default(CancellationToken));
Task SetNormalizedEmailAsync(TUser user, string normalizedEmail, CancellationToken cancellationToken);
}
}

20
src/Microsoft.AspNet.Identity/IUserLockoutStore.cs
View File

@ -20,8 +20,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<DateTimeOffset?> GetLockoutEndDateAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<DateTimeOffset?> GetLockoutEndDateAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Locks a user out until the specified end date (set to a past date, to unlock a user)
@ -30,8 +29,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="lockoutEnd"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetLockoutEndDateAsync(TUser user, DateTimeOffset? lockoutEnd,
CancellationToken cancellationToken = default(CancellationToken));
Task SetLockoutEndDateAsync(TUser user, DateTimeOffset? lockoutEnd, CancellationToken cancellationToken);
/// <summary>
/// Used to record when an attempt to access the user has failed
@ -39,8 +37,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<int> IncrementAccessFailedCountAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<int> IncrementAccessFailedCountAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Used to reset the account access count, typically after the account is successfully accessed
@ -48,7 +45,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task ResetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task ResetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns the current number of failed access attempts. This number usually will be reset whenever the
@ -57,8 +54,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<int> GetAccessFailedCountAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<int> GetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns whether the user can be locked out.
@ -66,8 +62,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetLockoutEnabledAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> GetLockoutEnabledAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Sets whether the user can be locked out.
@ -76,7 +71,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="enabled"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetLockoutEnabledAsync(TUser user, bool enabled,
CancellationToken cancellationToken = default(CancellationToken));
Task SetLockoutEnabledAsync(TUser user, bool enabled, CancellationToken cancellationToken);
}
}

12
src/Microsoft.AspNet.Identity/IUserLoginStore.cs
View File

@ -20,8 +20,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="login"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddLoginAsync(TUser user, UserLoginInfo login,
CancellationToken cancellationToken = default(CancellationToken));
Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken);
/// <summary>
/// Removes the user login with the specified combination if it exists, returns true if found and removed
@ -31,8 +30,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="providerKey"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveLoginAsync(TUser user, string loginProvider, string providerKey,
CancellationToken cancellationToken = default(CancellationToken));
Task RemoveLoginAsync(TUser user, string loginProvider, string providerKey, CancellationToken cancellationToken);
/// <summary>
/// Returns the linked accounts for this user
@ -40,8 +38,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<UserLoginInfo>> GetLoginsAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<IList<UserLoginInfo>> GetLoginsAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns the user associated with this login
@ -50,7 +47,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="providerKey"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByLoginAsync(string loginProvider, string providerKey,
CancellationToken cancellationToken = default(CancellationToken));
Task<TUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken);
}
}

8
src/Microsoft.AspNet.Identity/IUserPasswordStore.cs
View File

@ -19,8 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="passwordHash"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPasswordHashAsync(TUser user, string passwordHash,
CancellationToken cancellationToken = default(CancellationToken));
Task SetPasswordHashAsync(TUser user, string passwordHash, CancellationToken cancellationToken);
/// <summary>
/// Get the user password hash
@ -28,8 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetPasswordHashAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetPasswordHashAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns true if a user has a password set
@ -37,6 +35,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> HasPasswordAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<bool> HasPasswordAsync(TUser user, CancellationToken cancellationToken);
}
}

11
src/Microsoft.AspNet.Identity/IUserPhoneNumberStore.cs
View File

@ -19,8 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="phoneNumber"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPhoneNumberAsync(TUser user, string phoneNumber,
CancellationToken cancellationToken = default(CancellationToken));
Task SetPhoneNumberAsync(TUser user, string phoneNumber, CancellationToken cancellationToken);
/// <summary>
/// Get the user phoneNumber
@ -28,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetPhoneNumberAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetPhoneNumberAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns true if the user phone number is confirmed
@ -36,8 +35,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetPhoneNumberConfirmedAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> GetPhoneNumberConfirmedAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Sets whether the user phone number is confirmed
@ -46,7 +44,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="confirmed"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPhoneNumberConfirmedAsync(TUser user, bool confirmed,
CancellationToken cancellationToken = default(CancellationToken));
Task SetPhoneNumberConfirmedAsync(TUser user, bool confirmed, CancellationToken cancellationToken);
}
}

14
src/Microsoft.AspNet.Identity/IUserRoleStore.cs
View File

@ -20,8 +20,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddToRoleAsync(TUser user, string roleName,
CancellationToken cancellationToken = default(CancellationToken));
Task AddToRoleAsync(TUser user, string roleName, CancellationToken cancellationToken);
/// <summary>
/// Removes the role for the user
@ -30,8 +29,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveFromRoleAsync(TUser user, string roleName,
CancellationToken cancellationToken = default(CancellationToken));
Task RemoveFromRoleAsync(TUser user, string roleName, CancellationToken cancellationToken);
/// <summary>
/// Returns the roles for this user
@ -39,8 +37,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<string>> GetRolesAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<IList<string>> GetRolesAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns true if a user is in a role
@ -49,8 +46,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> IsInRoleAsync(TUser user, string roleName,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> IsInRoleAsync(TUser user, string roleName, CancellationToken cancellationToken);
/// <summary>
/// Returns all users in given role
@ -58,6 +54,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<TUser>> GetUsersInRoleAsync(string roleName, CancellationToken cancellationToken = default(CancellationToken));
Task<IList<TUser>> GetUsersInRoleAsync(string roleName, CancellationToken cancellationToken);
}
}

6
src/Microsoft.AspNet.Identity/IUserSecurityStampStore.cs
View File

@ -19,8 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="stamp"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetSecurityStampAsync(TUser user, string stamp,
CancellationToken cancellationToken = default(CancellationToken));
Task SetSecurityStampAsync(TUser user, string stamp, CancellationToken cancellationToken);
/// <summary>
/// Get the user security stamp
@ -28,7 +27,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetSecurityStampAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetSecurityStampAsync(TUser user, CancellationToken cancellationToken);
}
}

20
src/Microsoft.AspNet.Identity/IUserStore.cs
View File

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetUserIdAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetUserIdAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Returns the user's name
@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetUserNameAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetUserNameAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Set the user name
@ -37,7 +37,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetUserNameAsync(TUser user, string userName,
CancellationToken cancellationToken = default(CancellationToken));
CancellationToken cancellationToken);
/// <summary>
/// Returns the normalized user name
@ -45,7 +45,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetNormalizedUserNameAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<string> GetNormalizedUserNameAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Set the normalized user name
@ -55,7 +55,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetNormalizedUserNameAsync(TUser user, string normalizedName,
CancellationToken cancellationToken = default(CancellationToken));
CancellationToken cancellationToken);
/// <summary>
/// Insert a new user
@ -63,7 +63,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> CreateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> CreateAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// UpdateAsync a user
@ -71,7 +71,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// DeleteAsync a user
@ -79,7 +79,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> DeleteAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> DeleteAsync(TUser user, CancellationToken cancellationToken);
/// <summary>
/// Finds a user
@ -87,7 +87,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="userId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByIdAsync(string userId, CancellationToken cancellationToken = default(CancellationToken));
Task<TUser> FindByIdAsync(string userId, CancellationToken cancellationToken);
/// <summary>
/// Returns the user associated with this normalized user name
@ -95,6 +95,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedUserName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken = default(CancellationToken));
Task<TUser> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken);
}
}

16
src/Microsoft.AspNet.Identity/IUserTokenProvider.cs
View File

@ -22,10 +22,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="purpose"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user);
/// <summary>
/// ValidateAsync and unprotect a token, returns null if invalid
@ -34,10 +32,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user);
/// <summary>
/// Notifies the user that a token has been generated, i.e. via email or sms, or can no-op
@ -45,19 +41,15 @@ namespace Microsoft.AspNet.Identity
/// <param name="token"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task NotifyAsync(string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task NotifyAsync(string token, UserManager<TUser> manager, TUser user);
/// <summary>
/// Returns true if provider can be used for this user to generate two factor tokens, i.e. could require a user to have an email
/// </summary>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user);
}
}

6
src/Microsoft.AspNet.Identity/IUserTwoFactorStore.cs
View File

@ -19,8 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="enabled"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetTwoFactorEnabledAsync(TUser user, bool enabled,
CancellationToken cancellationToken = default(CancellationToken));
Task SetTwoFactorEnabledAsync(TUser user, bool enabled, CancellationToken cancellationToken);
/// <summary>
/// Returns whether two factor is enabled for the user
@ -28,7 +27,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetTwoFactorEnabledAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<bool> GetTwoFactorEnabledAsync(TUser user, CancellationToken cancellationToken);
}
}

4
src/Microsoft.AspNet.Identity/IUserValidator.cs
View File

@ -1,7 +1,6 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Threading;
using System.Threading.Tasks;
@ -20,7 +19,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken));
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user);
}
}

3
src/Microsoft.AspNet.Identity/PasswordValidator.cs
View File

@ -28,8 +28,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password,
CancellationToken cancellationToken = default(CancellationToken))
public virtual Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password)
{
if (password == null)
{

20
src/Microsoft.AspNet.Identity/PhoneNumberTokenProvider.cs
View File

@ -1,6 +1,5 @@
using System;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Framework.OptionsModel;
@ -44,15 +43,14 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
var phoneNumber = await manager.GetPhoneNumberAsync(user, cancellationToken);
return !string.IsNullOrWhiteSpace(phoneNumber) && await manager.IsPhoneNumberConfirmedAsync(user, cancellationToken);
var phoneNumber = await manager.GetPhoneNumberAsync(user);
return !string.IsNullOrWhiteSpace(phoneNumber) && await manager.IsPhoneNumberConfirmedAsync(user);
}
/// <summary>
@ -62,14 +60,13 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public override async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager,
TUser user, CancellationToken cancellationToken = default(CancellationToken))
public override async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
var phoneNumber = await manager.GetPhoneNumberAsync(user, cancellationToken);
var phoneNumber = await manager.GetPhoneNumberAsync(user);
return "PhoneNumber:" + purpose + ":" + phoneNumber;
}
@ -80,8 +77,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
@ -89,10 +85,10 @@ namespace Microsoft.AspNet.Identity
}
var msg = new IdentityMessage
{
Destination = await manager.GetPhoneNumberAsync(user, cancellationToken),
Destination = await manager.GetPhoneNumberAsync(user),
Body = string.Format(CultureInfo.CurrentCulture, Options.MessageFormat, token)
};
await manager.SendMessageAsync(Options.MessageProvider, msg, cancellationToken);
await manager.SendMessageAsync(Options.MessageProvider, msg);
}
}
}

126
src/Microsoft.AspNet.Identity/RoleManager.cs
View File

@ -7,6 +7,8 @@ using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Http;
using Microsoft.Framework.Logging;
namespace Microsoft.AspNet.Identity
@ -18,6 +20,7 @@ namespace Microsoft.AspNet.Identity
public class RoleManager<TRole> : IDisposable where TRole : class
{
private bool _disposed;
private HttpContext _context;
/// <summary>
/// Constructor
@ -28,7 +31,8 @@ namespace Microsoft.AspNet.Identity
IEnumerable<IRoleValidator<TRole>> roleValidators = null,
ILookupNormalizer keyNormalizer = null,
IdentityErrorDescriber errors = null,
ILogger<RoleManager<TRole>> logger = null)
ILogger<RoleManager<TRole>> logger = null,
IHttpContextAccessor contextAccessor = null)
{
if (store == null)
{
@ -37,6 +41,7 @@ namespace Microsoft.AspNet.Identity
Store = store;
KeyNormalizer = keyNormalizer ?? new UpperInvariantLookupNormalizer();
ErrorDescriber = errors ?? new IdentityErrorDescriber();
_context = contextAccessor?.Value;
if (roleValidators != null)
{
@ -114,6 +119,14 @@ namespace Microsoft.AspNet.Identity
}
}
private CancellationToken CancellationToken
{
get
{
return _context?.RequestAborted ?? CancellationToken.None;
}
}
/// <summary>
/// Dispose this object
/// </summary>
@ -123,12 +136,12 @@ namespace Microsoft.AspNet.Identity
GC.SuppressFinalize(this);
}
private async Task<IdentityResult> ValidateRoleInternal(TRole role, CancellationToken cancellationToken)
private async Task<IdentityResult> ValidateRoleInternal(TRole role)
{
var errors = new List<IdentityError>();
foreach (var v in RoleValidators)
{
var result = await v.ValidateAsync(this, role, cancellationToken);
var result = await v.ValidateAsync(this, role);
if (!result.Succeeded)
{
errors.AddRange(result.Errors);
@ -138,13 +151,11 @@ namespace Microsoft.AspNet.Identity
}
/// <summary>
/// CreateAsync a role
/// Create a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> CreateAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> CreateAsync(TRole role)
{
ThrowIfDisposed();
if (role == null)
@ -152,37 +163,33 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("role");
}
var result = await ValidateRoleInternal(role, cancellationToken);
var result = await ValidateRoleInternal(role);
if (!result.Succeeded)
{
return result;
}
await UpdateNormalizedRoleNameAsync(role, cancellationToken);
return await LogResultAsync(await Store.CreateAsync(role, cancellationToken), role);
await UpdateNormalizedRoleNameAsync(role);
return await LogResultAsync(await Store.CreateAsync(role, CancellationToken), role);
}
/// <summary>
/// Update the user's normalized user name
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task UpdateNormalizedRoleNameAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task UpdateNormalizedRoleNameAsync(TRole role)
{
var name = await GetRoleNameAsync(role, cancellationToken);
await Store.SetNormalizedRoleNameAsync(role, NormalizeKey(name), cancellationToken);
var name = await GetRoleNameAsync(role);
await Store.SetNormalizedRoleNameAsync(role, NormalizeKey(name), CancellationToken);
}
/// <summary>
/// UpdateAsync an existing role
/// Update an existing role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> UpdateAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> UpdateAsync(TRole role)
{
ThrowIfDisposed();
if (role == null)
@ -190,46 +197,41 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("role");
}
return await LogResultAsync(await UpdateRoleAsync(role, cancellationToken), role);
return await LogResultAsync(await UpdateRoleAsync(role), role);
}
private async Task<IdentityResult> UpdateRoleAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
private async Task<IdentityResult> UpdateRoleAsync(TRole role)
{
var result = await ValidateRoleInternal(role, cancellationToken);
var result = await ValidateRoleInternal(role);
if (!result.Succeeded)
{
return result;
}
await UpdateNormalizedRoleNameAsync(role, cancellationToken);
return await Store.UpdateAsync(role, cancellationToken);
await UpdateNormalizedRoleNameAsync(role);
return await Store.UpdateAsync(role, CancellationToken);
}
/// <summary>
/// DeleteAsync a role
/// Delete a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> DeleteAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> DeleteAsync(TRole role)
{
ThrowIfDisposed();
if (role == null)
{
throw new ArgumentNullException("role");
}
return await LogResultAsync(await Store.DeleteAsync(role, cancellationToken), role);
return await LogResultAsync(await Store.DeleteAsync(role, CancellationToken), role);
}
/// <summary>
/// Returns true if the role exists
/// </summary>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<bool> RoleExistsAsync(string roleName,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> RoleExistsAsync(string roleName)
{
ThrowIfDisposed();
if (roleName == null)
@ -237,7 +239,7 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("roleName");
}
return await FindByNameAsync(NormalizeKey(roleName), cancellationToken) != null;
return await FindByNameAsync(NormalizeKey(roleName)) != null;
}
/// <summary>
@ -252,29 +254,25 @@ namespace Microsoft.AspNet.Identity
/// <summary>
/// FindByLoginAsync a role by id
/// Find a role by id
/// </summary>
/// <param name="roleId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<TRole> FindByIdAsync(string roleId,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<TRole> FindByIdAsync(string roleId)
{
ThrowIfDisposed();
return await Store.FindByIdAsync(roleId, cancellationToken);
return await Store.FindByIdAsync(roleId, CancellationToken);
}
/// <summary>
/// Return the name of the role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<string> GetRoleNameAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<string> GetRoleNameAsync(TRole role)
{
ThrowIfDisposed();
return await Store.GetRoleNameAsync(role, cancellationToken);
return await Store.GetRoleNameAsync(role, CancellationToken);
}
/// <summary>
@ -282,14 +280,12 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="role"></param>
/// <param name="name"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> SetRoleNameAsync(TRole role, string name,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> SetRoleNameAsync(TRole role, string name)
{
ThrowIfDisposed();
await Store.SetRoleNameAsync(role, name, cancellationToken);
await UpdateNormalizedRoleNameAsync(role, cancellationToken);
await Store.SetRoleNameAsync(role, name, CancellationToken);
await UpdateNormalizedRoleNameAsync(role);
return await LogResultAsync(IdentityResult.Success, role);
}
@ -297,23 +293,19 @@ namespace Microsoft.AspNet.Identity
/// Return the role id for a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<string> GetRoleIdAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<string> GetRoleIdAsync(TRole role)
{
ThrowIfDisposed();
return await Store.GetRoleIdAsync(role, cancellationToken);
return await Store.GetRoleIdAsync(role, CancellationToken);
}
/// <summary>
/// FindByLoginAsync a role by name
/// </summary>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<TRole> FindByNameAsync(string roleName,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<TRole> FindByNameAsync(string roleName)
{
ThrowIfDisposed();
if (roleName == null)
@ -321,7 +313,7 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("roleName");
}
return await Store.FindByNameAsync(NormalizeKey(roleName), cancellationToken);
return await Store.FindByNameAsync(NormalizeKey(roleName), CancellationToken);
}
// IRoleClaimStore methods
@ -340,10 +332,8 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="role"></param>
/// <param name="claim"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> AddClaimAsync(TRole role, Claim claim,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> AddClaimAsync(TRole role, Claim claim)
{
ThrowIfDisposed();
var claimStore = GetClaimStore();
@ -355,8 +345,8 @@ namespace Microsoft.AspNet.Identity
{
throw new ArgumentNullException("role");
}
await claimStore.AddClaimAsync(role, claim, cancellationToken);
return await LogResultAsync(await UpdateRoleAsync(role, cancellationToken), role);
await claimStore.AddClaimAsync(role, claim, CancellationToken);
return await LogResultAsync(await UpdateRoleAsync(role), role);
}
/// <summary>
@ -364,10 +354,8 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="role"></param>
/// <param name="claim"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> RemoveClaimAsync(TRole role, Claim claim,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> RemoveClaimAsync(TRole role, Claim claim)
{
ThrowIfDisposed();
var claimStore = GetClaimStore();
@ -375,18 +363,16 @@ namespace Microsoft.AspNet.Identity
{
throw new ArgumentNullException("role");
}
await claimStore.RemoveClaimAsync(role, claim, cancellationToken);
return await LogResultAsync(await UpdateRoleAsync(role, cancellationToken), role);
await claimStore.RemoveClaimAsync(role, claim, CancellationToken);
return await LogResultAsync(await UpdateRoleAsync(role), role);
}
/// <summary>
/// Get a role's claims
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IList<Claim>> GetClaimsAsync(TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IList<Claim>> GetClaimsAsync(TRole role)
{
ThrowIfDisposed();
var claimStore = GetClaimStore();
@ -394,7 +380,7 @@ namespace Microsoft.AspNet.Identity
{
throw new ArgumentNullException("role");
}
return await claimStore.GetClaimsAsync(role, cancellationToken);
return await claimStore.GetClaimsAsync(role, CancellationToken);
}
/// <summary>

4
src/Microsoft.AspNet.Identity/RoleValidator.cs
View File

@ -3,7 +3,6 @@
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -28,8 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role)
{
if (manager == null)
{

7
src/Microsoft.AspNet.Identity/SecurityStampValidator.cs
View File

@ -19,12 +19,11 @@ namespace Microsoft.AspNet.Identity
/// ClaimsIdentity
/// </summary>
/// <returns></returns>
public virtual async Task ValidateAsync(CookieValidateIdentityContext context, ClaimsIdentity identity,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task ValidateAsync(CookieValidateIdentityContext context, ClaimsIdentity identity)
{
var manager = context.HttpContext.RequestServices.GetRequiredService<SignInManager<TUser>>();
var userId = identity.GetUserId();
var user = await manager.ValidateSecurityStampAsync(identity, userId, cancellationToken);
var user = await manager.ValidateSecurityStampAsync(identity, userId);
if (user != null)
{
var isPersistent = false;
@ -32,7 +31,7 @@ namespace Microsoft.AspNet.Identity
{
isPersistent = context.Properties.IsPersistent;
}
await manager.SignInAsync(user, isPersistent, authenticationMethod: null, cancellationToken: cancellationToken);
await manager.SignInAsync(user, isPersistent, authenticationMethod: null);
}
else
{

135
src/Microsoft.AspNet.Identity/SignInManager.cs
View File

@ -6,7 +6,6 @@ using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Http;
@ -56,28 +55,25 @@ namespace Microsoft.AspNet.Identity
public ILogger<SignInManager<TUser>> Logger { get; set; }
// Should this be a func?
public virtual async Task<ClaimsIdentity> CreateUserIdentityAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<ClaimsIdentity> CreateUserIdentityAsync(TUser user)
{
return await ClaimsFactory.CreateAsync(user);
}
public virtual async Task<bool> CanSignInAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> CanSignInAsync(TUser user)
{
if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user, cancellationToken)))
if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user)))
{
return await LogResultAsync(false, user);
}
if (Options.SignIn.RequireConfirmedPhoneNumber && !(await UserManager.IsPhoneNumberConfirmedAsync(user, cancellationToken)))
if (Options.SignIn.RequireConfirmedPhoneNumber && !(await UserManager.IsPhoneNumberConfirmedAsync(user)))
{
return await LogResultAsync(false, user);
}
return await LogResultAsync(true, user);
}
public virtual async Task SignInAsync(TUser user, bool isPersistent, string authenticationMethod = null,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task SignInAsync(TUser user, bool isPersistent, string authenticationMethod = null)
{
var userIdentity = await CreateUserIdentityAsync(user);
if (authenticationMethod != null)
@ -87,7 +83,6 @@ namespace Microsoft.AspNet.Identity
Context.Response.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, userIdentity);
}
// TODO: Should this be async?
public virtual void SignOut()
{
Context.Response.SignOut(IdentityOptions.ApplicationCookieAuthenticationType);
@ -95,29 +90,29 @@ namespace Microsoft.AspNet.Identity
Context.Response.SignOut(IdentityOptions.TwoFactorUserIdCookieAuthenticationType);
}
private async Task<bool> IsLockedOut(TUser user, CancellationToken token)
private async Task<bool> IsLockedOut(TUser user)
{
return UserManager.SupportsUserLockout && await UserManager.IsLockedOutAsync(user, token);
return UserManager.SupportsUserLockout && await UserManager.IsLockedOutAsync(user);
}
private async Task<SignInResult> PreSignInCheck(TUser user, CancellationToken token)
private async Task<SignInResult> PreSignInCheck(TUser user)
{
if (!await CanSignInAsync(user, token))
if (!await CanSignInAsync(user))
{
return SignInResult.NotAllowed;
}
if (await IsLockedOut(user, token))
if (await IsLockedOut(user))
{
return SignInResult.LockedOut;
}
return null;
}
private Task ResetLockout(TUser user, CancellationToken token)
private Task ResetLockout(TUser user)
{
if (UserManager.SupportsUserLockout)
{
return UserManager.ResetAccessFailedCountAsync(user, token);
return UserManager.ResetAccessFailedCountAsync(user);
}
return Task.FromResult(0);
}
@ -129,15 +124,14 @@ namespace Microsoft.AspNet.Identity
/// <param name="identity"></param>
/// <param name="userId"></param>
/// <returns></returns>
public virtual async Task<TUser> ValidateSecurityStampAsync(ClaimsIdentity identity, string userId,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<TUser> ValidateSecurityStampAsync(ClaimsIdentity identity, string userId)
{
var user = await UserManager.FindByIdAsync(userId, cancellationToken);
var user = await UserManager.FindByIdAsync(userId);
if (user != null && UserManager.SupportsUserSecurityStamp)
{
var securityStamp =
identity.FindFirstValue(Options.ClaimsIdentity.SecurityStampClaimType);
if (securityStamp == await UserManager.GetSecurityStampAsync(user, cancellationToken))
if (securityStamp == await UserManager.GetSecurityStampAsync(user))
{
return user;
}
@ -146,31 +140,31 @@ namespace Microsoft.AspNet.Identity
}
public virtual async Task<SignInResult> PasswordSignInAsync(TUser user, string password,
bool isPersistent, bool shouldLockout, CancellationToken cancellationToken = default(CancellationToken))
bool isPersistent, bool shouldLockout)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var error = await PreSignInCheck(user, cancellationToken);
var error = await PreSignInCheck(user);
if (error != null)
{
return await LogResultAsync(error, user);
}
if (await IsLockedOut(user, cancellationToken))
if (await IsLockedOut(user))
{
return await LogResultAsync(SignInResult.LockedOut, user);
}
if (await UserManager.CheckPasswordAsync(user, password, cancellationToken))
if (await UserManager.CheckPasswordAsync(user, password))
{
await ResetLockout(user, cancellationToken);
return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken), user);
await ResetLockout(user);
return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent), 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))
await UserManager.AccessFailedAsync(user);
if (await UserManager.IsLockedOutAsync(user))
{
return await LogResultAsync(SignInResult.LockedOut, user);
@ -180,14 +174,14 @@ namespace Microsoft.AspNet.Identity
}
public virtual async Task<SignInResult> PasswordSignInAsync(string userName, string password,
bool isPersistent, bool shouldLockout, CancellationToken cancellationToken = default(CancellationToken))
bool isPersistent, bool shouldLockout)
{
var user = await UserManager.FindByNameAsync(userName, cancellationToken);
var user = await UserManager.FindByNameAsync(userName);
if (user == null)
{
return SignInResult.Failed;
}
return await PasswordSignInAsync(user, password, isPersistent, shouldLockout, cancellationToken);
return await PasswordSignInAsync(user, password, isPersistent, shouldLockout);
}
private static ClaimsIdentity CreateIdentity(TwoFactorAuthenticationInfo info)
@ -205,87 +199,84 @@ namespace Microsoft.AspNet.Identity
return identity;
}
public virtual async Task<bool> SendTwoFactorCodeAsync(string provider,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> SendTwoFactorCodeAsync(string provider)
{
var twoFactorInfo = await RetrieveTwoFactorInfoAsync(cancellationToken);
var twoFactorInfo = await RetrieveTwoFactorInfoAsync();
if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{
return false;
}
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId, cancellationToken);
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId);
if (user == null)
{
return false;
}
var token = await UserManager.GenerateTwoFactorTokenAsync(user, provider, cancellationToken);
await UserManager.NotifyTwoFactorTokenAsync(user, provider, token, cancellationToken);
var token = await UserManager.GenerateTwoFactorTokenAsync(user, provider);
await UserManager.NotifyTwoFactorTokenAsync(user, provider, token);
return await LogResultAsync(true, user);
}
public virtual async Task<bool> IsTwoFactorClientRememberedAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> IsTwoFactorClientRememberedAsync(TUser user)
{
var userId = await UserManager.GetUserIdAsync(user, cancellationToken);
var userId = await UserManager.GetUserIdAsync(user);
var result =
await Context.AuthenticateAsync(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
return (result != null && result.Identity != null && result.Identity.Name == userId);
}
public virtual async Task RememberTwoFactorClientAsync(TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task RememberTwoFactorClientAsync(TUser user)
{
var userId = await UserManager.GetUserIdAsync(user, cancellationToken);
var userId = await UserManager.GetUserIdAsync(user);
var rememberBrowserIdentity = new ClaimsIdentity(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
rememberBrowserIdentity.AddClaim(new Claim(ClaimTypes.Name, userId));
Context.Response.SignIn(new AuthenticationProperties { IsPersistent = true }, rememberBrowserIdentity);
}
public virtual Task ForgetTwoFactorClientAsync(CancellationToken cancellationToken = default(CancellationToken))
public virtual Task ForgetTwoFactorClientAsync()
{
Context.Response.SignOut(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
return Task.FromResult(0);
}
public virtual async Task<SignInResult> TwoFactorSignInAsync(string provider, string code, bool isPersistent,
bool rememberClient, CancellationToken cancellationToken = default(CancellationToken))
bool rememberClient)
{
var twoFactorInfo = await RetrieveTwoFactorInfoAsync(cancellationToken);
var twoFactorInfo = await RetrieveTwoFactorInfoAsync();
if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{
return SignInResult.Failed;
}
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId, cancellationToken);
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId);
if (user == null)
{
return SignInResult.Failed;
}
var error = await PreSignInCheck(user, cancellationToken);
var error = await PreSignInCheck(user);
if (error != null)
{
return await LogResultAsync(error, user);
}
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code, cancellationToken))
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code))
{
// When token is verified correctly, clear the access failed count used for lockout
await ResetLockout(user, cancellationToken);
await ResetLockout(user);
// Cleanup external cookie
if (twoFactorInfo.LoginProvider != null)
{
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType);
}
await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider, cancellationToken);
await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider);
if (rememberClient)
{
await RememberTwoFactorClientAsync(user, cancellationToken);
await RememberTwoFactorClientAsync(user);
}
await UserManager.ResetAccessFailedCountAsync(user, cancellationToken);
await UserManager.ResetAccessFailedCountAsync(user);
await SignInAsync(user, isPersistent);
return await LogResultAsync(SignInResult.Success, user);
}
// If the token is incorrect, record the failure which also may cause the user to be locked out
await UserManager.AccessFailedAsync(user, cancellationToken);
await UserManager.AccessFailedAsync(user);
return await LogResultAsync(SignInResult.Failed, user);
}
@ -294,32 +285,30 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<TUser> GetTwoFactorAuthenticationUserAsync(
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<TUser> GetTwoFactorAuthenticationUserAsync()
{
var info = await RetrieveTwoFactorInfoAsync(cancellationToken);
var info = await RetrieveTwoFactorInfoAsync();
if (info == null)
{
return null;
}
return await UserManager.FindByIdAsync(info.UserId, cancellationToken);
return await UserManager.FindByIdAsync(info.UserId);
}
public virtual async Task<SignInResult> ExternalLoginSignInAsync(string loginProvider, string providerKey, bool isPersistent,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<SignInResult> ExternalLoginSignInAsync(string loginProvider, string providerKey, bool isPersistent)
{
var user = await UserManager.FindByLoginAsync(loginProvider, providerKey, cancellationToken);
var user = await UserManager.FindByLoginAsync(loginProvider, providerKey);
if (user == null)
{
return SignInResult.Failed;
}
var error = await PreSignInCheck(user, cancellationToken);
var error = await PreSignInCheck(user);
if (error != null)
{
return await LogResultAsync(error, user);
}
return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken, loginProvider), user);
return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent, loginProvider), user);
}
private const string LoginProviderKey = "LoginProvider";
@ -330,8 +319,7 @@ namespace Microsoft.AspNet.Identity
return Context.GetAuthenticationTypes().Where(d => !string.IsNullOrEmpty(d.Caption));
}
public virtual async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(string expectedXsrf = null,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(string expectedXsrf = null)
{
var auth = await Context.AuthenticateAsync(IdentityOptions.ExternalCookieAuthenticationType);
if (auth == null || auth.Identity == null || auth.Properties.Dictionary == null || !auth.Properties.Dictionary.ContainsKey(LoginProviderKey))
@ -372,17 +360,16 @@ namespace Microsoft.AspNet.Identity
return properties;
}
private async Task<SignInResult> SignInOrTwoFactorAsync(TUser user, bool isPersistent,
CancellationToken cancellationToken, string loginProvider = null)
private async Task<SignInResult> SignInOrTwoFactorAsync(TUser user, bool isPersistent, string loginProvider = null)
{
if (UserManager.SupportsUserTwoFactor &&
await UserManager.GetTwoFactorEnabledAsync(user, cancellationToken) &&
(await UserManager.GetValidTwoFactorProvidersAsync(user, cancellationToken)).Count > 0)
await UserManager.GetTwoFactorEnabledAsync(user) &&
(await UserManager.GetValidTwoFactorProvidersAsync(user)).Count > 0)
{
if (!await IsTwoFactorClientRememberedAsync(user, cancellationToken))
if (!await IsTwoFactorClientRememberedAsync(user))
{
// Store the userId for use after two factor check
var userId = await UserManager.GetUserIdAsync(user, cancellationToken);
var userId = await UserManager.GetUserIdAsync(user);
Context.Response.SignIn(StoreTwoFactorInfo(userId, loginProvider));
return SignInResult.TwoFactorRequired;
}
@ -392,11 +379,11 @@ namespace Microsoft.AspNet.Identity
{
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType);
}
await SignInAsync(user, isPersistent, loginProvider, cancellationToken);
await SignInAsync(user, isPersistent, loginProvider);
return SignInResult.Success;
}
private async Task<TwoFactorAuthenticationInfo> RetrieveTwoFactorInfoAsync(CancellationToken cancellationToken)
private async Task<TwoFactorAuthenticationInfo> RetrieveTwoFactorInfoAsync()
{
var result = await Context.AuthenticateAsync(IdentityOptions.TwoFactorUserIdCookieAuthenticationType);
if (result != null && result.Identity != null)

18
src/Microsoft.AspNet.Identity/TotpSecurityStampBasedTokenProvider.cs
View File

@ -22,8 +22,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
{
return Task.FromResult(0);
}
@ -35,14 +34,13 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
var token = await manager.CreateSecurityTokenAsync(user, cancellationToken);
var token = await manager.CreateSecurityTokenAsync(user);
var modifier = await GetUserModifierAsync(purpose, manager, user);
return Rfc6238AuthenticationService.GenerateCode(token, modifier).ToString("D6", CultureInfo.InvariantCulture);
}
@ -55,8 +53,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager,
TUser user, CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
@ -67,7 +64,7 @@ namespace Microsoft.AspNet.Identity
{
return false;
}
var securityToken = await manager.CreateSecurityTokenAsync(user, cancellationToken);
var securityToken = await manager.CreateSecurityTokenAsync(user);
var modifier = await GetUserModifierAsync(purpose, manager, user);
return securityToken != null && Rfc6238AuthenticationService.ValidateCode(securityToken, code, modifier);
}
@ -79,8 +76,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <returns></returns>
public virtual async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user)
{
if (manager == null)
{
@ -90,6 +86,6 @@ namespace Microsoft.AspNet.Identity
return "Totp:" + purpose + ":" + userId;
}
public abstract Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
public abstract Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user);
}
}

615
src/Microsoft.AspNet.Identity/UserManager.cs
View File

File diff suppressed because it is too large Load Diff

3
src/Microsoft.AspNet.Identity/UserValidator.cs
View File

@ -32,8 +32,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user,
CancellationToken cancellationToken = default(CancellationToken))
public virtual async Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user)
{
if (manager == null)
{

16
test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs
View File

@ -44,18 +44,18 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
userManager.Setup(m => m.SupportsUserClaim).Returns(supportClaims);
userManager.Setup(m => m.SupportsUserRole).Returns(supportRoles);
userManager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id);
userManager.Setup(m => m.GetUserNameAsync(user, CancellationToken.None)).ReturnsAsync(user.UserName);
userManager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id);
userManager.Setup(m => m.GetUserNameAsync(user)).ReturnsAsync(user.UserName);
var roleClaims = new[] { "Admin", "Local" };
if (supportRoles)
{
userManager.Setup(m => m.GetRolesAsync(user, CancellationToken.None)).ReturnsAsync(roleClaims);
userManager.Setup(m => m.GetRolesAsync(user)).ReturnsAsync(roleClaims);
roleManager.Setup(m => m.SupportsRoleClaims).Returns(supportRoleClaims);
}
var userClaims = new[] { new Claim("Whatever", "Value"), new Claim("Whatever2", "Value2") };
if (supportClaims)
{
userManager.Setup(m => m.GetClaimsAsync(user, CancellationToken.None)).ReturnsAsync(userClaims);
userManager.Setup(m => m.GetClaimsAsync(user)).ReturnsAsync(userClaims);
}
userManager.Object.Options = new IdentityOptions();
@ -65,10 +65,10 @@ namespace Microsoft.AspNet.Identity.Test
var localClaims = new[] { new Claim("LocalClaim1", "Value1"), new Claim("LocalClaim2", "Value2") };
if (supportRoleClaims)
{
roleManager.Setup(m => m.FindByNameAsync("Admin", CancellationToken.None)).ReturnsAsync(admin);
roleManager.Setup(m => m.FindByNameAsync("Local", CancellationToken.None)).ReturnsAsync(local);
roleManager.Setup(m => m.GetClaimsAsync(admin, CancellationToken.None)).ReturnsAsync(adminClaims);
roleManager.Setup(m => m.GetClaimsAsync(local, CancellationToken.None)).ReturnsAsync(localClaims);
roleManager.Setup(m => m.FindByNameAsync("Admin")).ReturnsAsync(admin);
roleManager.Setup(m => m.FindByNameAsync("Local")).ReturnsAsync(local);
roleManager.Setup(m => m.GetClaimsAsync(admin)).ReturnsAsync(adminClaims);
roleManager.Setup(m => m.GetClaimsAsync(local)).ReturnsAsync(localClaims);
}
var options = new Mock<IOptions<IdentityOptions>>();

6
test/Microsoft.AspNet.Identity.Test/IdentityBuilderTest.cs
View File

@ -209,17 +209,17 @@ namespace Microsoft.AspNet.Identity.Test
throw new NotImplementedException();
}
public Task<IdentityResult> ValidateAsync(RoleManager<IdentityRole> manager, IdentityRole role, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(RoleManager<IdentityRole> manager, IdentityRole role)
{
throw new NotImplementedException();
}
public Task<IdentityResult> ValidateAsync(UserManager<IdentityUser> manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(UserManager<IdentityUser> manager, IdentityUser user)
{
throw new NotImplementedException();
}
public Task<IdentityResult> ValidateAsync(UserManager<IdentityUser> manager, IdentityUser user, string password, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(UserManager<IdentityUser> manager, IdentityUser user, string password)
{
throw new NotImplementedException();
}

12
test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs
View File

@ -48,8 +48,8 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null);
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id, CancellationToken.None)).ReturnsAsync(user).Verifiable();
signInManager.Setup(s => s.SignInAsync(user, isPersistent, null, CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).ReturnsAsync(user).Verifiable();
signInManager.Setup(s => s.SignInAsync(user, isPersistent, null)).Returns(Task.FromResult(0)).Verifiable();
var services = new ServiceCollection();
services.AddInstance(options.Object);
services.AddInstance(signInManager.Object);
@ -83,7 +83,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null);
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id, CancellationToken.None)).ReturnsAsync(null).Verifiable();
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).ReturnsAsync(null).Verifiable();
var services = new ServiceCollection();
services.AddInstance(options.Object);
services.AddInstance(signInManager.Object);
@ -117,7 +117,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null);
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id, CancellationToken.None)).ReturnsAsync(null).Verifiable();
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).ReturnsAsync(null).Verifiable();
var services = new ServiceCollection();
services.AddInstance(options.Object);
services.AddInstance(signInManager.Object);
@ -151,8 +151,8 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null);
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id, CancellationToken.None)).Throws(new Exception("Shouldn't be called"));
signInManager.Setup(s => s.SignInAsync(user, false, null, CancellationToken.None)).Throws(new Exception("Shouldn't be called"));
signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).Throws(new Exception("Shouldn't be called"));
signInManager.Setup(s => s.SignInAsync(user, false, null)).Throws(new Exception("Shouldn't be called"));
var services = new ServiceCollection();
services.AddInstance(options.Object);
services.AddInstance(signInManager.Object);

112
test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs
View File

@ -89,7 +89,7 @@ namespace Microsoft.AspNet.Identity.Test
// var identityFactory = new Mock<IClaimsIdentityFactory<TestUser>>();
// const string authType = "Test";
// var testIdentity = new ClaimsIdentity(authType);
// identityFactory.Setup(s => s.CreateAsync(userManager, user, authType, CancellationToken.None)).ReturnsAsync(testIdentity).Verifiable();
// identityFactory.Setup(s => s.CreateAsync(userManager, user, authType)).ReturnsAsync(testIdentity).Verifiable();
// userManager.ClaimsIdentityFactory = identityFactory.Object;
// var context = new Mock<HttpContext>();
// var response = new Mock<HttpResponse>();
@ -116,9 +116,9 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>();
@ -152,11 +152,11 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
@ -169,7 +169,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
claimsFactory.Setup(m => m.CreateAsync(user)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
var logStore = new StringBuilder();
var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, logger.Object);
@ -195,11 +195,11 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
@ -236,19 +236,19 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout)
{
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
}
IList<string> providers = new List<string>();
providers.Add("PhoneNumber");
manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user, CancellationToken.None)).Returns(Task.FromResult(providers)).Verifiable();
manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).Returns(Task.FromResult(providers)).Verifiable();
manager.Setup(m => m.SupportsUserTwoFactor).Returns(true).Verifiable();
manager.Setup(m => m.GetTwoFactorEnabledAsync(user, CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
if (supportsLockout)
{
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).Verifiable();
}
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
@ -293,10 +293,10 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout)
{
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
}
manager.Setup(m => m.FindByLoginAsync(loginProvider, providerKey, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.FindByLoginAsync(loginProvider, providerKey)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
@ -312,7 +312,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
claimsFactory.Setup(m => m.CreateAsync(user)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
var logStore = new StringBuilder();
var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, logger.Object);
@ -358,13 +358,13 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout)
{
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).Verifiable();
}
manager.Setup(m => m.FindByIdAsync(user.Id, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code, CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.GetUserNameAsync(user, CancellationToken.None)).ReturnsAsync(user.UserName).Verifiable();
manager.Setup(m => m.FindByIdAsync(user.Id)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.GetUserNameAsync(user)).ReturnsAsync(user.UserName).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
var contextAccessor = new Mock<IHttpContextAccessor>();
@ -433,7 +433,7 @@ namespace Microsoft.AspNet.Identity.Test
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new ClaimsIdentityFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(
It.Is<AuthenticationProperties>(v => v.IsPersistent == true),
@ -463,16 +463,16 @@ namespace Microsoft.AspNet.Identity.Test
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.GetTwoFactorEnabledAsync(user, CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable();
IList<string> providers = new List<string>();
providers.Add("PhoneNumber");
manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user, CancellationToken.None)).Returns(Task.FromResult(providers)).Verifiable();
manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).Returns(Task.FromResult(providers)).Verifiable();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.SupportsUserTwoFactor).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
@ -488,7 +488,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType)).Verifiable();
claimsFactory.Setup(m => m.CreateAsync(user)).ReturnsAsync(new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType)).Verifiable();
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
// Act
@ -545,10 +545,10 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -577,7 +577,7 @@ namespace Microsoft.AspNet.Identity.Test
{
// Setup
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.FindByNameAsync("bogus", CancellationToken.None)).ReturnsAsync(null).Verifiable();
manager.Setup(m => m.FindByNameAsync("bogus")).ReturnsAsync(null).Verifiable();
var context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -605,15 +605,15 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
var lockedout = false;
manager.Setup(m => m.AccessFailedAsync(user, CancellationToken.None)).Returns(() =>
manager.Setup(m => m.AccessFailedAsync(user)).Returns(() =>
{
lockedout = true;
return Task.FromResult(IdentityResult.Success);
}).Verifiable();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).Returns(() => Task.FromResult(lockedout));
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user)).Returns(() => Task.FromResult(lockedout));
manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable();
var context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -641,17 +641,17 @@ namespace Microsoft.AspNet.Identity.Test
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.IsEmailConfirmedAsync(user, CancellationToken.None)).ReturnsAsync(confirmed).Verifiable();
manager.Setup(m => m.IsEmailConfirmedAsync(user)).ReturnsAsync(confirmed).Verifiable();
if (confirmed)
{
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
}
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
if (confirmed)
{
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(It.Is<AuthenticationProperties>(v => v.IsPersistent == false), It.IsAny<ClaimsIdentity>())).Verifiable();
}
@ -690,13 +690,13 @@ namespace Microsoft.AspNet.Identity.Test
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.IsPhoneNumberConfirmedAsync(user, CancellationToken.None)).ReturnsAsync(confirmed).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id.ToString()).Verifiable();
manager.Setup(m => m.IsPhoneNumberConfirmedAsync(user)).ReturnsAsync(confirmed).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id.ToString()).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
if (confirmed)
{
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(It.Is<AuthenticationProperties>(v => v.IsPersistent == false), It.IsAny<ClaimsIdentity>())).Verifiable();
}

11
test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs
View File

@ -817,7 +817,7 @@ namespace Microsoft.AspNet.Identity.Test
{
public static readonly IdentityError ErrorMessage = new IdentityError { Description = "I'm Bad." };
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password)
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
@ -1088,23 +1088,22 @@ namespace Microsoft.AspNet.Identity.Test
{
public string Name { get; } = "Noop";
public Task<string> GenerateAsync(string purpose, UserManager<TestUser> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<string> GenerateAsync(string purpose, UserManager<TestUser> manager, TestUser user)
{
return Task.FromResult("Test");
}
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TestUser> manager,
TestUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TestUser> manager, TestUser user)
{
return Task.FromResult(true);
}
public Task NotifyAsync(string token, UserManager<TestUser> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task NotifyAsync(string token, UserManager<TestUser> manager, TestUser user)
{
return Task.FromResult(0);
}
public Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TestUser> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TestUser> manager, TestUser user)
{
return Task.FromResult(true);
}

26
test/Shared/ApiConsistencyTestBase.cs
View File

@ -71,7 +71,7 @@ namespace Microsoft.AspNet.Identity.Test
//}
[Fact]
public void Async_methods_should_have_overload_with_cancellation_token_and_end_with_async_suffix()
public void Async_methods_should_end_with_async_suffix()
{
var asyncMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
@ -81,30 +81,6 @@ namespace Microsoft.AspNet.Identity.Test
where typeof(Task).IsAssignableFrom(method.ReturnType)
select method).ToList();
var asyncMethodsWithToken
= (from method in asyncMethods
where method.GetParameters().Any(pi => pi.ParameterType == typeof(CancellationToken))
select method).ToList();
var asyncMethodsWithoutToken
= (from method in asyncMethods
where method.GetParameters().All(pi => pi.ParameterType != typeof(CancellationToken))
select method).ToList();
var missingOverloads
= (from methodWithoutToken in asyncMethodsWithoutToken
where !asyncMethodsWithToken
.Any(methodWithToken => methodWithoutToken.Name == methodWithToken.Name
&& methodWithoutToken.ReflectedType == methodWithToken.ReflectedType)
// ReSharper disable once PossibleNullReferenceException
select methodWithoutToken.DeclaringType.Name + "." + methodWithoutToken.Name)
.Except(GetCancellationTokenExceptions())
.ToList();
Assert.False(
missingOverloads.Any(),
"\r\n-- Missing async overloads --\r\n" + string.Join("\r\n", missingOverloads));
var missingSuffixMethods
= asyncMethods
.Where(method => !method.Name.EndsWith("Async"))

6
test/Shared/MockHelpers.cs
View File

@ -18,7 +18,7 @@ namespace Microsoft.AspNet.Identity.Test
public static Mock<UserManager<TUser>> MockUserManager<TUser>() where TUser : class
{
var store = new Mock<IUserStore<TUser>>();
var mgr = new Mock<UserManager<TUser>>(store.Object, null, null, null, null, null, null, null, null, null);
var mgr = new Mock<UserManager<TUser>>(store.Object, null, null, null, null, null, null, null, null, null, null);
mgr.Object.UserValidators.Add(new UserValidator<TUser>());
mgr.Object.PasswordValidators.Add(new PasswordValidator<TUser>());
return mgr;
@ -29,7 +29,7 @@ namespace Microsoft.AspNet.Identity.Test
store = store ?? new Mock<IRoleStore<TRole>>().Object;
var roles = new List<IRoleValidator<TRole>>();
roles.Add(new RoleValidator<TRole>());
return new Mock<RoleManager<TRole>>(store, roles, null, null, null);
return new Mock<RoleManager<TRole>>(store, roles, null, null, null, null);
}
public static Mock<ILogger<T>> MockILogger<T>(StringBuilder logStore = null) where T : class
@ -53,7 +53,7 @@ namespace Microsoft.AspNet.Identity.Test
var userManager = new UserManager<TUser>(store);
userManager.UserValidators.Add(validator.Object);
userManager.PasswordValidators.Add(new PasswordValidator<TUser>());
validator.Setup(v => v.ValidateAsync(userManager, It.IsAny<TUser>(), CancellationToken.None))
validator.Setup(v => v.ValidateAsync(userManager, It.IsAny<TUser>()))
.Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
return userManager;
}

16
test/Shared/UserManagerTestBase.cs
View File

@ -611,24 +611,22 @@ namespace Microsoft.AspNet.Identity.Test
{
public string Name { get; } = "Static";
public Task<string> GenerateAsync(string purpose, UserManager<TUser> manager,
TUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
{
return Task.FromResult(MakeToken(purpose, user));
}
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager,
TUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
{
return Task.FromResult(token == MakeToken(purpose, user));
}
public Task NotifyAsync(string token, UserManager<TUser> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
{
return Task.FromResult(0);
}
public Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
{
return Task.FromResult(true);
}
@ -965,17 +963,17 @@ namespace Microsoft.AspNet.Identity.Test
{
public static readonly IdentityError ErrorMessage = new IdentityError { Description = "I'm Bad.", Code = "BadValidator" };
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password)
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
public Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(RoleManager<TRole> manager, TRole role)
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken))
public Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user)
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}