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="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> /// <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> /// <returns>A <see cref="Task{TResult}"/> that represents the started task.</returns>
public virtual async Task<ClaimsIdentity> CreateAsync( public virtual async Task<ClaimsIdentity> CreateAsync(TUser user)
TUser user,
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (user == null) if (user == null)
{ {
throw new ArgumentNullException("user"); throw new ArgumentNullException("user");
} }
var userId = await UserManager.GetUserIdAsync(user, cancellationToken); var userId = await UserManager.GetUserIdAsync(user);
var userName = await UserManager.GetUserNameAsync(user, cancellationToken); var userName = await UserManager.GetUserNameAsync(user);
var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType, Options.ClaimsIdentity.UserNameClaimType, var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType, Options.ClaimsIdentity.UserNameClaimType,
Options.ClaimsIdentity.RoleClaimType); Options.ClaimsIdentity.RoleClaimType);
id.AddClaim(new Claim(Options.ClaimsIdentity.UserIdClaimType, userId)); id.AddClaim(new Claim(Options.ClaimsIdentity.UserIdClaimType, userId));
@ -94,11 +92,11 @@ namespace Microsoft.AspNet.Identity
if (UserManager.SupportsUserSecurityStamp) if (UserManager.SupportsUserSecurityStamp)
{ {
id.AddClaim(new Claim(Options.ClaimsIdentity.SecurityStampClaimType, id.AddClaim(new Claim(Options.ClaimsIdentity.SecurityStampClaimType,
await UserManager.GetSecurityStampAsync(user, cancellationToken))); await UserManager.GetSecurityStampAsync(user)));
} }
if (UserManager.SupportsUserRole) if (UserManager.SupportsUserRole)
{ {
var roles = await UserManager.GetRolesAsync(user, cancellationToken); var roles = await UserManager.GetRolesAsync(user);
foreach (var roleName in roles) foreach (var roleName in roles)
{ {
id.AddClaim(new Claim(Options.ClaimsIdentity.RoleClaimType, roleName, ClaimValueTypes.String)); id.AddClaim(new Claim(Options.ClaimsIdentity.RoleClaimType, roleName, ClaimValueTypes.String));
@ -107,14 +105,14 @@ namespace Microsoft.AspNet.Identity
var role = await RoleManager.FindByNameAsync(roleName); var role = await RoleManager.FindByNameAsync(roleName);
if (role != null) if (role != null)
{ {
id.AddClaims(await RoleManager.GetClaimsAsync(role, cancellationToken)); id.AddClaims(await RoleManager.GetClaimsAsync(role));
} }
} }
} }
} }
if (UserManager.SupportsUserClaim) if (UserManager.SupportsUserClaim)
{ {
id.AddClaims(await UserManager.GetClaimsAsync(user, cancellationToken)); id.AddClaims(await UserManager.GetClaimsAsync(user));
} }
return id; 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="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> /// <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> /// <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, public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (user == null) if (user == null)
{ {
throw new ArgumentNullException("user"); throw new ArgumentNullException("user");
} }
var ms = new MemoryStream(); var ms = new MemoryStream();
var userId = await manager.GetUserIdAsync(user, cancellationToken); var userId = await manager.GetUserIdAsync(user);
using (var writer = ms.CreateWriter()) using (var writer = ms.CreateWriter())
{ {
writer.Write(DateTimeOffset.UtcNow); writer.Write(DateTimeOffset.UtcNow);
@ -97,10 +96,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token">The token to validate.</param> /// <param name="token">The token to validate.</param>
/// <param name="manager">The <see cref="UserManager{TUser}"/> to retrieve user properties from.</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="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> /// <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, public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
try try
{ {
@ -116,7 +113,7 @@ namespace Microsoft.AspNet.Identity
} }
var userId = reader.ReadString(); var userId = reader.ReadString();
var actualUserId = await manager.GetUserIdAsync(user, cancellationToken); var actualUserId = await manager.GetUserIdAsync(user);
if (userId != actualUserId) if (userId != actualUserId)
{ {
return false; return false;
@ -155,8 +152,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user">The <see cref="TUser"/> the token was generated for.</param> /// <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> /// <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> /// <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, public virtual Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(false); return Task.FromResult(false);
} }
@ -167,10 +163,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token">The token to generate notifications for..</param> /// <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="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="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> /// <returns>A <see cref="Task{TResult}"/> that represents the started task.</returns>
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user, public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(0); 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="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user, public override async Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var email = await manager.GetEmailAsync(user, cancellationToken); var email = await manager.GetEmailAsync(user);
return !string.IsNullOrWhiteSpace(email) && await manager.IsEmailConfirmedAsync(user, cancellationToken); return !string.IsNullOrWhiteSpace(email) && await manager.IsEmailConfirmedAsync(user);
} }
/// <summary> /// <summary>
@ -61,9 +60,9 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public override async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, 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; return "Email:" + purpose + ":" + email;
} }
@ -74,8 +73,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user, public override async Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (manager == null) if (manager == null)
{ {
@ -83,11 +81,11 @@ namespace Microsoft.AspNet.Identity
} }
var msg = new IdentityMessage var msg = new IdentityMessage
{ {
Destination = await manager.GetEmailAsync(user, cancellationToken), Destination = await manager.GetEmailAsync(user),
Subject = Options.Subject, Subject = Options.Subject,
Body = string.Format(CultureInfo.CurrentCulture, Options.BodyFormat, token) 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> /// </summary>
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="authenticationType"></param> /// <param name="authenticationType"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns> /// <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; } 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 /// Validate the password for the user
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password, Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, string password);
CancellationToken cancellationToken = default(CancellationToken));
} }
} }

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

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

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

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

@ -20,8 +20,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<IList<Claim>> GetClaimsAsync(TUser user, Task<IList<Claim>> GetClaimsAsync(TUser user, CancellationToken cancellationToken);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// Add a new user claim /// Add a new user claim
@ -30,7 +29,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="claims"></param> /// <param name="claims"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task AddClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken = default(CancellationToken)); Task AddClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Updates the give claim information with the given new claim information /// 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="newClaim"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <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> /// <summary>
/// Remove a user claim /// Remove a user claim
@ -49,8 +48,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="claims"></param> /// <param name="claims"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task RemoveClaimsAsync(TUser user, IEnumerable<Claim> claims, Task RemoveClaimsAsync(TUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// Get users having a specific claim /// Get users having a specific claim
@ -58,6 +56,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="claim">Claim to look up</param> /// <param name="claim">Claim to look up</param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <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="email"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken = default(CancellationToken)); Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Get the user email /// Get the user email
@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GetEmailAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<string> GetEmailAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Returns true if the user email is confirmed /// Returns true if the user email is confirmed
@ -35,8 +35,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<bool> GetEmailConfirmedAsync(TUser user, Task<bool> GetEmailConfirmedAsync(TUser user, CancellationToken cancellationToken);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// Sets whether the user email is confirmed /// Sets whether the user email is confirmed
@ -45,8 +44,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="confirmed"></param> /// <param name="confirmed"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task SetEmailConfirmedAsync(TUser user, bool confirmed, Task SetEmailConfirmedAsync(TUser user, bool confirmed, CancellationToken cancellationToken);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// Returns the user associated with this email /// Returns the user associated with this email
@ -54,7 +52,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedEmail"></param> /// <param name="normalizedEmail"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken = default(CancellationToken)); Task<TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Returns the normalized email /// Returns the normalized email
@ -62,7 +60,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GetNormalizedEmailAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<string> GetNormalizedEmailAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Set the normalized email /// Set the normalized email
@ -71,8 +69,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedEmail"></param> /// <param name="normalizedEmail"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task SetNormalizedEmailAsync(TUser user, string normalizedEmail, Task SetNormalizedEmailAsync(TUser user, string normalizedEmail, CancellationToken cancellationToken);
CancellationToken cancellationToken = default(CancellationToken));
} }
} }

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

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

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

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

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

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

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

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

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

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GetUserIdAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<string> GetUserIdAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Returns the user's name /// Returns the user's name
@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GetUserNameAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<string> GetUserNameAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Set the user name /// Set the user name
@ -37,7 +37,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task SetUserNameAsync(TUser user, string userName, Task SetUserNameAsync(TUser user, string userName,
CancellationToken cancellationToken = default(CancellationToken)); CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Returns the normalized user name /// Returns the normalized user name
@ -45,7 +45,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GetNormalizedUserNameAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<string> GetNormalizedUserNameAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Set the normalized user name /// Set the normalized user name
@ -55,7 +55,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task SetNormalizedUserNameAsync(TUser user, string normalizedName, Task SetNormalizedUserNameAsync(TUser user, string normalizedName,
CancellationToken cancellationToken = default(CancellationToken)); CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Insert a new user /// Insert a new user
@ -63,7 +63,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<IdentityResult> CreateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<IdentityResult> CreateAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// UpdateAsync a user /// UpdateAsync a user
@ -71,7 +71,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// DeleteAsync a user /// DeleteAsync a user
@ -79,7 +79,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<IdentityResult> DeleteAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)); Task<IdentityResult> DeleteAsync(TUser user, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Finds a user /// Finds a user
@ -87,7 +87,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="userId"></param> /// <param name="userId"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<TUser> FindByIdAsync(string userId, CancellationToken cancellationToken = default(CancellationToken)); Task<TUser> FindByIdAsync(string userId, CancellationToken cancellationToken);
/// <summary> /// <summary>
/// Returns the user associated with this normalized user name /// Returns the user associated with this normalized user name
@ -95,6 +95,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="normalizedUserName"></param> /// <param name="normalizedUserName"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <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="purpose"></param>
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user, Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// ValidateAsync and unprotect a token, returns null if invalid /// ValidateAsync and unprotect a token, returns null if invalid
@ -34,10 +32,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="token"></param> /// <param name="token"></param>
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user, Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <summary>
/// Notifies the user that a token has been generated, i.e. via email or sms, or can no-op /// 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="token"></param>
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task NotifyAsync(string token, UserManager<TUser> manager, TUser user, Task NotifyAsync(string token, UserManager<TUser> manager, TUser user);
CancellationToken cancellationToken = default(CancellationToken));
/// <summary> /// <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 /// 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> /// </summary>
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user, Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user);
CancellationToken cancellationToken = default(CancellationToken));
} }
} }

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

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

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

@ -1,7 +1,6 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. // 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. // 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;
using System.Threading.Tasks; using System.Threading.Tasks;
@ -20,7 +19,6 @@ namespace Microsoft.AspNet.Identity
/// <param name="user"></param> /// <param name="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user);
CancellationToken cancellationToken = default(CancellationToken));
} }
} }

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

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

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

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

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

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

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

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

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

@ -6,7 +6,6 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Security.Claims; using System.Security.Claims;
using System.Security.Principal; using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNet.Hosting; using Microsoft.AspNet.Hosting;
using Microsoft.AspNet.Http; using Microsoft.AspNet.Http;
@ -56,28 +55,25 @@ namespace Microsoft.AspNet.Identity
public ILogger<SignInManager<TUser>> Logger { get; set; } public ILogger<SignInManager<TUser>> Logger { get; set; }
// Should this be a func? // Should this be a func?
public virtual async Task<ClaimsIdentity> CreateUserIdentityAsync(TUser user, public virtual async Task<ClaimsIdentity> CreateUserIdentityAsync(TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
return await ClaimsFactory.CreateAsync(user); return await ClaimsFactory.CreateAsync(user);
} }
public virtual async Task<bool> CanSignInAsync(TUser user, public virtual async Task<bool> CanSignInAsync(TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user, cancellationToken))) if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user)))
{ {
return await LogResultAsync(false, 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(false, user);
} }
return await LogResultAsync(true, user); return await LogResultAsync(true, user);
} }
public virtual async Task SignInAsync(TUser user, bool isPersistent, string authenticationMethod = null, public virtual async Task SignInAsync(TUser user, bool isPersistent, string authenticationMethod = null)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var userIdentity = await CreateUserIdentityAsync(user); var userIdentity = await CreateUserIdentityAsync(user);
if (authenticationMethod != null) if (authenticationMethod != null)
@ -87,7 +83,6 @@ namespace Microsoft.AspNet.Identity
Context.Response.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, userIdentity); Context.Response.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, userIdentity);
} }
// TODO: Should this be async?
public virtual void SignOut() public virtual void SignOut()
{ {
Context.Response.SignOut(IdentityOptions.ApplicationCookieAuthenticationType); Context.Response.SignOut(IdentityOptions.ApplicationCookieAuthenticationType);
@ -95,29 +90,29 @@ namespace Microsoft.AspNet.Identity
Context.Response.SignOut(IdentityOptions.TwoFactorUserIdCookieAuthenticationType); 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; return SignInResult.NotAllowed;
} }
if (await IsLockedOut(user, token)) if (await IsLockedOut(user))
{ {
return SignInResult.LockedOut; return SignInResult.LockedOut;
} }
return null; return null;
} }
private Task ResetLockout(TUser user, CancellationToken token) private Task ResetLockout(TUser user)
{ {
if (UserManager.SupportsUserLockout) if (UserManager.SupportsUserLockout)
{ {
return UserManager.ResetAccessFailedCountAsync(user, token); return UserManager.ResetAccessFailedCountAsync(user);
} }
return Task.FromResult(0); return Task.FromResult(0);
} }
@ -129,15 +124,14 @@ namespace Microsoft.AspNet.Identity
/// <param name="identity"></param> /// <param name="identity"></param>
/// <param name="userId"></param> /// <param name="userId"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<TUser> ValidateSecurityStampAsync(ClaimsIdentity identity, string userId, public virtual async Task<TUser> ValidateSecurityStampAsync(ClaimsIdentity identity, string userId)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var user = await UserManager.FindByIdAsync(userId, cancellationToken); var user = await UserManager.FindByIdAsync(userId);
if (user != null && UserManager.SupportsUserSecurityStamp) if (user != null && UserManager.SupportsUserSecurityStamp)
{ {
var securityStamp = var securityStamp =
identity.FindFirstValue(Options.ClaimsIdentity.SecurityStampClaimType); identity.FindFirstValue(Options.ClaimsIdentity.SecurityStampClaimType);
if (securityStamp == await UserManager.GetSecurityStampAsync(user, cancellationToken)) if (securityStamp == await UserManager.GetSecurityStampAsync(user))
{ {
return user; return user;
} }
@ -146,31 +140,31 @@ namespace Microsoft.AspNet.Identity
} }
public virtual async Task<SignInResult> PasswordSignInAsync(TUser user, string password, 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) if (user == null)
{ {
throw new ArgumentNullException(nameof(user)); throw new ArgumentNullException(nameof(user));
} }
var error = await PreSignInCheck(user, cancellationToken); var error = await PreSignInCheck(user);
if (error != null) if (error != null)
{ {
return await LogResultAsync(error, user); return await LogResultAsync(error, user);
} }
if (await IsLockedOut(user, cancellationToken)) if (await IsLockedOut(user))
{ {
return await LogResultAsync(SignInResult.LockedOut, user); return await LogResultAsync(SignInResult.LockedOut, user);
} }
if (await UserManager.CheckPasswordAsync(user, password, cancellationToken)) if (await UserManager.CheckPasswordAsync(user, password))
{ {
await ResetLockout(user, cancellationToken); await ResetLockout(user);
return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken), user); return await LogResultAsync(await SignInOrTwoFactorAsync(user, isPersistent), user);
} }
if (UserManager.SupportsUserLockout && shouldLockout) if (UserManager.SupportsUserLockout && shouldLockout)
{ {
// If lockout is requested, increment access failed count which might lock out the user // If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailedAsync(user, cancellationToken); await UserManager.AccessFailedAsync(user);
if (await UserManager.IsLockedOutAsync(user, cancellationToken)) if (await UserManager.IsLockedOutAsync(user))
{ {
return await LogResultAsync(SignInResult.LockedOut, 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, 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) if (user == null)
{ {
return SignInResult.Failed; return SignInResult.Failed;
} }
return await PasswordSignInAsync(user, password, isPersistent, shouldLockout, cancellationToken); return await PasswordSignInAsync(user, password, isPersistent, shouldLockout);
} }
private static ClaimsIdentity CreateIdentity(TwoFactorAuthenticationInfo info) private static ClaimsIdentity CreateIdentity(TwoFactorAuthenticationInfo info)
@ -205,87 +199,84 @@ namespace Microsoft.AspNet.Identity
return identity; return identity;
} }
public virtual async Task<bool> SendTwoFactorCodeAsync(string provider, public virtual async Task<bool> SendTwoFactorCodeAsync(string provider)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var twoFactorInfo = await RetrieveTwoFactorInfoAsync(cancellationToken); var twoFactorInfo = await RetrieveTwoFactorInfoAsync();
if (twoFactorInfo == null || twoFactorInfo.UserId == null) if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{ {
return false; return false;
} }
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId, cancellationToken); var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId);
if (user == null) if (user == null)
{ {
return false; return false;
} }
var token = await UserManager.GenerateTwoFactorTokenAsync(user, provider, cancellationToken); var token = await UserManager.GenerateTwoFactorTokenAsync(user, provider);
await UserManager.NotifyTwoFactorTokenAsync(user, provider, token, cancellationToken); await UserManager.NotifyTwoFactorTokenAsync(user, provider, token);
return await LogResultAsync(true, user); return await LogResultAsync(true, user);
} }
public virtual async Task<bool> IsTwoFactorClientRememberedAsync(TUser user, public virtual async Task<bool> IsTwoFactorClientRememberedAsync(TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var userId = await UserManager.GetUserIdAsync(user, cancellationToken); var userId = await UserManager.GetUserIdAsync(user);
var result = var result =
await Context.AuthenticateAsync(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType); await Context.AuthenticateAsync(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
return (result != null && result.Identity != null && result.Identity.Name == userId); return (result != null && result.Identity != null && result.Identity.Name == userId);
} }
public virtual async Task RememberTwoFactorClientAsync(TUser user, public virtual async Task RememberTwoFactorClientAsync(TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var userId = await UserManager.GetUserIdAsync(user, cancellationToken); var userId = await UserManager.GetUserIdAsync(user);
var rememberBrowserIdentity = new ClaimsIdentity(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType); var rememberBrowserIdentity = new ClaimsIdentity(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
rememberBrowserIdentity.AddClaim(new Claim(ClaimTypes.Name, userId)); rememberBrowserIdentity.AddClaim(new Claim(ClaimTypes.Name, userId));
Context.Response.SignIn(new AuthenticationProperties { IsPersistent = true }, rememberBrowserIdentity); 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); Context.Response.SignOut(IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
return Task.FromResult(0); return Task.FromResult(0);
} }
public virtual async Task<SignInResult> TwoFactorSignInAsync(string provider, string code, bool isPersistent, 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) if (twoFactorInfo == null || twoFactorInfo.UserId == null)
{ {
return SignInResult.Failed; return SignInResult.Failed;
} }
var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId, cancellationToken); var user = await UserManager.FindByIdAsync(twoFactorInfo.UserId);
if (user == null) if (user == null)
{ {
return SignInResult.Failed; return SignInResult.Failed;
} }
var error = await PreSignInCheck(user, cancellationToken); var error = await PreSignInCheck(user);
if (error != null) if (error != null)
{ {
return await LogResultAsync(error, user); 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 // When token is verified correctly, clear the access failed count used for lockout
await ResetLockout(user, cancellationToken); await ResetLockout(user);
// Cleanup external cookie // Cleanup external cookie
if (twoFactorInfo.LoginProvider != null) if (twoFactorInfo.LoginProvider != null)
{ {
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType); Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType);
} }
await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider, cancellationToken); await SignInAsync(user, isPersistent, twoFactorInfo.LoginProvider);
if (rememberClient) if (rememberClient)
{ {
await RememberTwoFactorClientAsync(user, cancellationToken); await RememberTwoFactorClientAsync(user);
} }
await UserManager.ResetAccessFailedCountAsync(user, cancellationToken); await UserManager.ResetAccessFailedCountAsync(user);
await SignInAsync(user, isPersistent); await SignInAsync(user, isPersistent);
return await LogResultAsync(SignInResult.Success, user); return await LogResultAsync(SignInResult.Success, user);
} }
// If the token is incorrect, record the failure which also may cause the user to be locked out // 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); return await LogResultAsync(SignInResult.Failed, user);
} }
@ -294,32 +285,30 @@ namespace Microsoft.AspNet.Identity
/// </summary> /// </summary>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<TUser> GetTwoFactorAuthenticationUserAsync( public virtual async Task<TUser> GetTwoFactorAuthenticationUserAsync()
CancellationToken cancellationToken = default(CancellationToken))
{ {
var info = await RetrieveTwoFactorInfoAsync(cancellationToken); var info = await RetrieveTwoFactorInfoAsync();
if (info == null) if (info == null)
{ {
return 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, public virtual async Task<SignInResult> ExternalLoginSignInAsync(string loginProvider, string providerKey, bool isPersistent)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var user = await UserManager.FindByLoginAsync(loginProvider, providerKey, cancellationToken); var user = await UserManager.FindByLoginAsync(loginProvider, providerKey);
if (user == null) if (user == null)
{ {
return SignInResult.Failed; return SignInResult.Failed;
} }
var error = await PreSignInCheck(user, cancellationToken); var error = await PreSignInCheck(user);
if (error != null) if (error != null)
{ {
return await LogResultAsync(error, user); 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"; private const string LoginProviderKey = "LoginProvider";
@ -330,8 +319,7 @@ namespace Microsoft.AspNet.Identity
return Context.GetAuthenticationTypes().Where(d => !string.IsNullOrEmpty(d.Caption)); return Context.GetAuthenticationTypes().Where(d => !string.IsNullOrEmpty(d.Caption));
} }
public virtual async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(string expectedXsrf = null, public virtual async Task<ExternalLoginInfo> GetExternalLoginInfoAsync(string expectedXsrf = null)
CancellationToken cancellationToken = default(CancellationToken))
{ {
var auth = await Context.AuthenticateAsync(IdentityOptions.ExternalCookieAuthenticationType); var auth = await Context.AuthenticateAsync(IdentityOptions.ExternalCookieAuthenticationType);
if (auth == null || auth.Identity == null || auth.Properties.Dictionary == null || !auth.Properties.Dictionary.ContainsKey(LoginProviderKey)) 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; return properties;
} }
private async Task<SignInResult> SignInOrTwoFactorAsync(TUser user, bool isPersistent, private async Task<SignInResult> SignInOrTwoFactorAsync(TUser user, bool isPersistent, string loginProvider = null)
CancellationToken cancellationToken, string loginProvider = null)
{ {
if (UserManager.SupportsUserTwoFactor && if (UserManager.SupportsUserTwoFactor &&
await UserManager.GetTwoFactorEnabledAsync(user, cancellationToken) && await UserManager.GetTwoFactorEnabledAsync(user) &&
(await UserManager.GetValidTwoFactorProvidersAsync(user, cancellationToken)).Count > 0) (await UserManager.GetValidTwoFactorProvidersAsync(user)).Count > 0)
{ {
if (!await IsTwoFactorClientRememberedAsync(user, cancellationToken)) if (!await IsTwoFactorClientRememberedAsync(user))
{ {
// Store the userId for use after two factor check // 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)); Context.Response.SignIn(StoreTwoFactorInfo(userId, loginProvider));
return SignInResult.TwoFactorRequired; return SignInResult.TwoFactorRequired;
} }
@ -392,11 +379,11 @@ namespace Microsoft.AspNet.Identity
{ {
Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType); Context.Response.SignOut(IdentityOptions.ExternalCookieAuthenticationType);
} }
await SignInAsync(user, isPersistent, loginProvider, cancellationToken); await SignInAsync(user, isPersistent, loginProvider);
return SignInResult.Success; return SignInResult.Success;
} }
private async Task<TwoFactorAuthenticationInfo> RetrieveTwoFactorInfoAsync(CancellationToken cancellationToken) private async Task<TwoFactorAuthenticationInfo> RetrieveTwoFactorInfoAsync()
{ {
var result = await Context.AuthenticateAsync(IdentityOptions.TwoFactorUserIdCookieAuthenticationType); var result = await Context.AuthenticateAsync(IdentityOptions.TwoFactorUserIdCookieAuthenticationType);
if (result != null && result.Identity != null) 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="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user, public virtual Task NotifyAsync(string token, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(0); return Task.FromResult(0);
} }
@ -35,14 +34,13 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user, public virtual async Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (manager == null) if (manager == null)
{ {
throw new ArgumentNullException("manager"); throw new ArgumentNullException("manager");
} }
var token = await manager.CreateSecurityTokenAsync(user, cancellationToken); var token = await manager.CreateSecurityTokenAsync(user);
var modifier = await GetUserModifierAsync(purpose, manager, user); var modifier = await GetUserModifierAsync(purpose, manager, user);
return Rfc6238AuthenticationService.GenerateCode(token, modifier).ToString("D6", CultureInfo.InvariantCulture); return Rfc6238AuthenticationService.GenerateCode(token, modifier).ToString("D6", CultureInfo.InvariantCulture);
} }
@ -55,8 +53,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, public virtual async Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
TUser user, CancellationToken cancellationToken = default(CancellationToken))
{ {
if (manager == null) if (manager == null)
{ {
@ -67,7 +64,7 @@ namespace Microsoft.AspNet.Identity
{ {
return false; return false;
} }
var securityToken = await manager.CreateSecurityTokenAsync(user, cancellationToken); var securityToken = await manager.CreateSecurityTokenAsync(user);
var modifier = await GetUserModifierAsync(purpose, manager, user); var modifier = await GetUserModifierAsync(purpose, manager, user);
return securityToken != null && Rfc6238AuthenticationService.ValidateCode(securityToken, code, modifier); return securityToken != null && Rfc6238AuthenticationService.ValidateCode(securityToken, code, modifier);
} }
@ -79,8 +76,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param> /// <param name="manager"></param>
/// <param name="user"></param> /// <param name="user"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user, public virtual async Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (manager == null) if (manager == null)
{ {
@ -90,6 +86,6 @@ namespace Microsoft.AspNet.Identity
return "Totp:" + purpose + ":" + userId; 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="user"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <returns></returns>
public virtual async Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user, public virtual async Task<IdentityResult> ValidateAsync(UserManager<TUser> manager, TUser user)
CancellationToken cancellationToken = default(CancellationToken))
{ {
if (manager == null) 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" }; var user = new TestUser { UserName = "Foo" };
userManager.Setup(m => m.SupportsUserClaim).Returns(supportClaims); userManager.Setup(m => m.SupportsUserClaim).Returns(supportClaims);
userManager.Setup(m => m.SupportsUserRole).Returns(supportRoles); userManager.Setup(m => m.SupportsUserRole).Returns(supportRoles);
userManager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id); userManager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id);
userManager.Setup(m => m.GetUserNameAsync(user, CancellationToken.None)).ReturnsAsync(user.UserName); userManager.Setup(m => m.GetUserNameAsync(user)).ReturnsAsync(user.UserName);
var roleClaims = new[] { "Admin", "Local" }; var roleClaims = new[] { "Admin", "Local" };
if (supportRoles) 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); roleManager.Setup(m => m.SupportsRoleClaims).Returns(supportRoleClaims);
} }
var userClaims = new[] { new Claim("Whatever", "Value"), new Claim("Whatever2", "Value2") }; var userClaims = new[] { new Claim("Whatever", "Value"), new Claim("Whatever2", "Value2") };
if (supportClaims) 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(); 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") }; var localClaims = new[] { new Claim("LocalClaim1", "Value1"), new Claim("LocalClaim2", "Value2") };
if (supportRoleClaims) if (supportRoleClaims)
{ {
roleManager.Setup(m => m.FindByNameAsync("Admin", CancellationToken.None)).ReturnsAsync(admin); roleManager.Setup(m => m.FindByNameAsync("Admin")).ReturnsAsync(admin);
roleManager.Setup(m => m.FindByNameAsync("Local", CancellationToken.None)).ReturnsAsync(local); roleManager.Setup(m => m.FindByNameAsync("Local")).ReturnsAsync(local);
roleManager.Setup(m => m.GetClaimsAsync(admin, CancellationToken.None)).ReturnsAsync(adminClaims); roleManager.Setup(m => m.GetClaimsAsync(admin)).ReturnsAsync(adminClaims);
roleManager.Setup(m => m.GetClaimsAsync(local, CancellationToken.None)).ReturnsAsync(localClaims); roleManager.Setup(m => m.GetClaimsAsync(local)).ReturnsAsync(localClaims);
} }
var options = new Mock<IOptions<IdentityOptions>>(); 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(); 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(); 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(); 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(); 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); contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object, var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null); 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.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).ReturnsAsync(user).Verifiable();
signInManager.Setup(s => s.SignInAsync(user, isPersistent, null, CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); signInManager.Setup(s => s.SignInAsync(user, isPersistent, null)).Returns(Task.FromResult(0)).Verifiable();
var services = new ServiceCollection(); var services = new ServiceCollection();
services.AddInstance(options.Object); services.AddInstance(options.Object);
services.AddInstance(signInManager.Object); services.AddInstance(signInManager.Object);
@ -83,7 +83,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object); contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object, var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null); 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(); var services = new ServiceCollection();
services.AddInstance(options.Object); services.AddInstance(options.Object);
services.AddInstance(signInManager.Object); services.AddInstance(signInManager.Object);
@ -117,7 +117,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object); contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object, var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null); 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(); var services = new ServiceCollection();
services.AddInstance(options.Object); services.AddInstance(options.Object);
services.AddInstance(signInManager.Object); services.AddInstance(signInManager.Object);
@ -151,8 +151,8 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object); contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object, var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object,
contextAccessor.Object, claimsManager.Object, options.Object, null); 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.ValidateSecurityStampAsync(It.IsAny<ClaimsIdentity>(), user.Id)).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.SignInAsync(user, false, null)).Throws(new Exception("Shouldn't be called"));
var services = new ServiceCollection(); var services = new ServiceCollection();
services.AddInstance(options.Object); services.AddInstance(options.Object);
services.AddInstance(signInManager.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>>(); // var identityFactory = new Mock<IClaimsIdentityFactory<TestUser>>();
// const string authType = "Test"; // const string authType = "Test";
// var testIdentity = new ClaimsIdentity(authType); // 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; // userManager.ClaimsIdentityFactory = identityFactory.Object;
// var context = new Mock<HttpContext>(); // var context = new Mock<HttpContext>();
// var response = new Mock<HttpResponse>(); // var response = new Mock<HttpResponse>();
@ -116,9 +116,9 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).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 context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>(); var contextAccessor = new Mock<IHttpContextAccessor>();
@ -152,11 +152,11 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
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.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
@ -169,7 +169,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>(); var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions); options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object); 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 logStore = new StringBuilder();
var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore); var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, logger.Object); 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 user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
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.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
@ -236,19 +236,19 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout) 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>(); IList<string> providers = new List<string>();
providers.Add("PhoneNumber"); 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.SupportsUserTwoFactor).Returns(true).Verifiable();
manager.Setup(m => m.GetTwoFactorEnabledAsync(user, CancellationToken.None)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable(); manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
if (supportsLockout) 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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
@ -293,10 +293,10 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout) 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.FindByLoginAsync(loginProvider, providerKey)).ReturnsAsync(user).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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
@ -312,7 +312,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>(); var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions); options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object); 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 logStore = new StringBuilder();
var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore); var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, logger.Object); 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(); manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable();
if (supportsLockout) 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.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).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.FindByIdAsync(user.Id)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code, CancellationToken.None)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable(); manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.GetUserNameAsync(user, CancellationToken.None)).ReturnsAsync(user.UserName).Verifiable(); manager.Setup(m => m.GetUserNameAsync(user)).ReturnsAsync(user.UserName).Verifiable();
var context = new Mock<HttpContext>(); var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
var contextAccessor = new Mock<IHttpContextAccessor>(); var contextAccessor = new Mock<IHttpContextAccessor>();
@ -433,7 +433,7 @@ namespace Microsoft.AspNet.Identity.Test
options.Setup(a => a.Options).Returns(identityOptions); options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new ClaimsIdentityFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object); 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(); context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn( response.Setup(r => r.SignIn(
It.Is<AuthenticationProperties>(v => v.IsPersistent == true), It.Is<AuthenticationProperties>(v => v.IsPersistent == true),
@ -463,16 +463,16 @@ namespace Microsoft.AspNet.Identity.Test
// Setup // Setup
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); 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>(); IList<string> providers = new List<string>();
providers.Add("PhoneNumber"); 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.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.SupportsUserTwoFactor).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.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable(); manager.Setup(m => m.GetUserIdAsync(user)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
var context = new Mock<HttpContext>(); var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable(); context.Setup(c => c.Response).Returns(response.Object).Verifiable();
@ -488,7 +488,7 @@ namespace Microsoft.AspNet.Identity.Test
var options = new Mock<IOptions<IdentityOptions>>(); var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions); options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object); 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); var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
// Act // Act
@ -545,10 +545,10 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).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 context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>(); var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object); contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -577,7 +577,7 @@ namespace Microsoft.AspNet.Identity.Test
{ {
// Setup // Setup
var manager = MockHelpers.MockUserManager<TestUser>(); 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 context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>(); var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object); contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -605,15 +605,15 @@ namespace Microsoft.AspNet.Identity.Test
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
var lockedout = false; var lockedout = false;
manager.Setup(m => m.AccessFailedAsync(user, CancellationToken.None)).Returns(() => manager.Setup(m => m.AccessFailedAsync(user)).Returns(() =>
{ {
lockedout = true; lockedout = true;
return Task.FromResult(IdentityResult.Success); return Task.FromResult(IdentityResult.Success);
}).Verifiable(); }).Verifiable();
manager.Setup(m => m.SupportsUserLockout).Returns(true).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.IsLockedOutAsync(user)).Returns(() => Task.FromResult(lockedout));
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable();
var context = new Mock<HttpContext>(); var context = new Mock<HttpContext>();
var contextAccessor = new Mock<IHttpContextAccessor>(); var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.Value).Returns(context.Object); contextAccessor.Setup(a => a.Value).Returns(context.Object);
@ -641,17 +641,17 @@ namespace Microsoft.AspNet.Identity.Test
// Setup // Setup
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); 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) 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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
if (confirmed) 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(); 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(); 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 // Setup
var user = new TestUser { UserName = "Foo" }; var user = new TestUser { UserName = "Foo" };
var manager = MockHelpers.MockUserManager<TestUser>(); var manager = MockHelpers.MockUserManager<TestUser>();
manager.Setup(m => m.IsPhoneNumberConfirmedAsync(user, CancellationToken.None)).ReturnsAsync(confirmed).Verifiable(); manager.Setup(m => m.IsPhoneNumberConfirmedAsync(user)).ReturnsAsync(confirmed).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 context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>(); var response = new Mock<HttpResponse>();
if (confirmed) 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(); 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(); 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 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)); return Task.FromResult(IdentityResult.Failed(ErrorMessage));
} }
@ -1088,23 +1088,22 @@ namespace Microsoft.AspNet.Identity.Test
{ {
public string Name { get; } = "Noop"; 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"); return Task.FromResult("Test");
} }
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TestUser> manager, public Task<bool> ValidateAsync(string purpose, string token, UserManager<TestUser> manager, TestUser user)
TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(true); 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); 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); return Task.FromResult(true);
} }

26
test/Shared/ApiConsistencyTestBase.cs
View File

@ -71,7 +71,7 @@ namespace Microsoft.AspNet.Identity.Test
//} //}
[Fact] [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 var asyncMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes()) = (from type in GetAllTypes(TargetAssembly.GetTypes())
@ -81,30 +81,6 @@ namespace Microsoft.AspNet.Identity.Test
where typeof(Task).IsAssignableFrom(method.ReturnType) where typeof(Task).IsAssignableFrom(method.ReturnType)
select method).ToList(); 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 var missingSuffixMethods
= asyncMethods = asyncMethods
.Where(method => !method.Name.EndsWith("Async")) .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 public static Mock<UserManager<TUser>> MockUserManager<TUser>() where TUser : class
{ {
var store = new Mock<IUserStore<TUser>>(); 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.UserValidators.Add(new UserValidator<TUser>());
mgr.Object.PasswordValidators.Add(new PasswordValidator<TUser>()); mgr.Object.PasswordValidators.Add(new PasswordValidator<TUser>());
return mgr; return mgr;
@ -29,7 +29,7 @@ namespace Microsoft.AspNet.Identity.Test
store = store ?? new Mock<IRoleStore<TRole>>().Object; store = store ?? new Mock<IRoleStore<TRole>>().Object;
var roles = new List<IRoleValidator<TRole>>(); var roles = new List<IRoleValidator<TRole>>();
roles.Add(new RoleValidator<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 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); var userManager = new UserManager<TUser>(store);
userManager.UserValidators.Add(validator.Object); userManager.UserValidators.Add(validator.Object);
userManager.PasswordValidators.Add(new PasswordValidator<TUser>()); 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(); .Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
return userManager; return userManager;
} }

16
test/Shared/UserManagerTestBase.cs
View File

@ -611,24 +611,22 @@ namespace Microsoft.AspNet.Identity.Test
{ {
public string Name { get; } = "Static"; public string Name { get; } = "Static";
public Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, public Task<string> GenerateAsync(string purpose, UserManager<TUser> manager, TUser user)
TUser user, CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(MakeToken(purpose, user)); return Task.FromResult(MakeToken(purpose, user));
} }
public Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, public Task<bool> ValidateAsync(string purpose, string token, UserManager<TUser> manager, TUser user)
TUser user, CancellationToken cancellationToken = default(CancellationToken))
{ {
return Task.FromResult(token == MakeToken(purpose, 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); 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); 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 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)); 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)); 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)); return Task.FromResult(IdentityResult.Failed(ErrorMessage));
} }