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

Add support for UserClaims

This commit is contained in:
Hao Kung 2014-05-07 17:29:06 -07:00
parent 71750d668b
commit ace88b21be
5 changed files with 132 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/Microsoft.AspNet.Identity.Entity/IdentitySqlContext.cs
View File

@ -36,6 +36,7 @@ namespace Microsoft.AspNet.Identity.Entity
{
public DbSet<TUser> Users { get; set; }
public DbSet<IdentityUserClaim> UserClaims { get; set; }
//public DbSet<TRole> Roles { get; set; }
public IdentitySqlContext(IServiceProvider serviceProvider)
@ -46,7 +47,7 @@ namespace Microsoft.AspNet.Identity.Entity
protected override void OnConfiguring(DbContextOptions builder)
{
// TODO: pull connection string from config
builder.UseSqlServer(@"Server=(localdb)\v11.0;Database=SimpleIdentity3;Trusted_Connection=True;");
builder.UseSqlServer(@"Server=(localdb)\v11.0;Database=SimpleIdentity5;Trusted_Connection=True;");
}
protected override void OnModelCreating(ModelBuilder builder)
@ -55,6 +56,12 @@ namespace Microsoft.AspNet.Identity.Entity
.Key(u => u.Id)
.Properties(ps => ps.Property(u => u.UserName))
.ToTable("AspNetUsers");
builder.Entity<IdentityUserClaim>()
.Key(uc => uc.Id)
// TODO: this throws a length exception currently, investigate
//.ForeignKeys(fk => fk.ForeignKey<TUser>(f => f.UserId))
.ToTable("AspNetUserClaims");
}
}
}

50
src/Microsoft.AspNet.Identity.Entity/SqlUserStore.cs
View File

@ -37,7 +37,8 @@ namespace Microsoft.AspNet.Identity.Entity
public class UserStore<TUser> :
//IUserRoleStore<TUser>,
IUserPasswordStore<TUser>,
IQueryableUserStore<TUser>
IQueryableUserStore<TUser>,
IUserClaimStore<TUser>
where TUser : User
{
private bool _disposed;
@ -347,5 +348,52 @@ namespace Microsoft.AspNet.Identity.Entity
{
_disposed = true;
}
private DbSet<IdentityUserClaim> UserClaims { get { return Context.Set<IdentityUserClaim>(); } }
public Task<IList<Claim>> GetClaimsAsync(TUser user, CancellationToken cancellationToken = new CancellationToken())
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException("user");
}
IList<Claim> result = UserClaims.Where(uc => uc.UserId == user.Id).Select(c => new Claim(c.ClaimType, c.ClaimValue)).ToList();
return Task.FromResult(result);
}
public Task AddClaimAsync(TUser user, Claim claim, CancellationToken cancellationToken = new CancellationToken())
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException("user");
}
if (claim == null)
{
throw new ArgumentNullException("claim");
}
UserClaims.Add(new IdentityUserClaim { UserId = user.Id, ClaimType = claim.Type, ClaimValue = claim.Value });
return Task.FromResult(0);
}
public Task RemoveClaimAsync(TUser user, Claim claim, CancellationToken cancellationToken = new CancellationToken())
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException("user");
}
if (claim == null)
{
throw new ArgumentNullException("claim");
}
var claims = UserClaims.Where(uc => uc.ClaimValue == claim.Value && uc.ClaimType == claim.Type).ToList();
foreach (var c in claims)
{
UserClaims.Remove(c);
}
return Task.FromResult(0);
}
}
}

4
src/Microsoft.AspNet.Identity.InMemory/IdentityBuilderExtensions.cs
View File

@ -9,9 +9,9 @@ namespace Microsoft.AspNet.Identity
where TUser : IdentityUser
where TRole : IdentityRole
{
builder.Services.AddScoped<IUserStore<TUser>, InMemoryUserStore<TUser>>();
builder.Services.AddSingleton<IUserStore<TUser>, InMemoryUserStore<TUser>>();
builder.Services.AddScoped<UserManager<TUser>, UserManager<TUser>>();
builder.Services.AddScoped<IRoleStore<TRole>, InMemoryRoleStore<TRole>>();
builder.Services.AddSingleton<IRoleStore<TRole>, InMemoryRoleStore<TRole>>();
builder.Services.AddScoped<RoleManager<TRole>, RoleManager<TRole>>();
return builder;
}

41
test/Microsoft.AspNet.Identity.Entity.Test/SqlUserStoreTest.cs
View File

@ -214,8 +214,8 @@ namespace Microsoft.AspNet.Identity.Entity.Test
[Fact]
public async Task CanChangePassword()
{
var manager = TestIdentityFactory.CreateManager();
var user = new EntityUser("ChangePasswordTest");
var manager = CreateManager();
var user = new User("ChangePasswordTest");
const string password = "password";
const string newPassword = "newpassword";
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password));
@ -229,5 +229,42 @@ namespace Microsoft.AspNet.Identity.Entity.Test
IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user));
}
[Fact]
public async Task ClaimsIdentityCreatesExpectedClaims()
{
var manager = CreateManager();
//var role = TestIdentityFactory.CreateRoleManager(context);
var user = new User("Hao");
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
//IdentityResultAssert.IsSuccess(await role.CreateAsync(new EntityRole("Admin")));
//IdentityResultAssert.IsSuccess(await role.CreateAsync(new EntityRole("Local")));
//IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Admin"));
//IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Local"));
Claim[] userClaims =
{
new Claim("Whatever", "Value"),
new Claim("Whatever2", "Value2")
};
foreach (var c in userClaims)
{
IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c));
}
var identity = await manager.CreateIdentityAsync(user, "test");
var claimsFactory = (ClaimsIdentityFactory<User>)manager.ClaimsIdentityFactory;
Assert.NotNull(claimsFactory);
var claims = identity.Claims.ToList();
Assert.NotNull(claims);
Assert.True(
claims.Any(c => c.Type == manager.Options.ClaimType.UserName && c.Value == user.UserName));
Assert.True(claims.Any(c => c.Type == manager.Options.ClaimType.UserId && c.Value == user.Id.ToString()));
//Assert.True(claims.Any(c => c.Type == manager.Options.ClaimType.Role && c.Value == "Admin"));
//Assert.True(claims.Any(c => c.Type == manager.Options.ClaimType.Role && c.Value == "Local"));
foreach (var cl in userClaims)
{
Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));
}
IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user));
}
}
}

34
test/Microsoft.AspNet.Identity.InMemory.Test/StartupTest.cs
View File

@ -111,6 +111,40 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
await CreateAdminUser(builder.ApplicationServices);
}
[Fact]
public void VerifyUseInMemoryLifetimes()
{
IBuilder builder = new Microsoft.AspNet.Builder.Builder(new ServiceCollection().BuildServiceProvider());
builder.UseServices(services =>
{
services.AddIdentity<ApplicationUser>(s => s.AddInMemory());
services.AddTransient<ApplicationUserManager>();
services.AddTransient<ApplicationRoleManager>();
});
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
var roleStore = builder.ApplicationServices.GetService<IRoleStore<IdentityRole>>();
var userManager = builder.ApplicationServices.GetService<ApplicationUserManager>();
var roleManager = builder.ApplicationServices.GetService<ApplicationRoleManager>();
Assert.NotNull(userStore);
Assert.NotNull(userManager);
Assert.NotNull(roleStore);
Assert.NotNull(roleManager);
var userStore2 = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
var roleStore2 = builder.ApplicationServices.GetService<IRoleStore<IdentityRole>>();
var userManager2 = builder.ApplicationServices.GetService<ApplicationUserManager>();
var roleManager2 = builder.ApplicationServices.GetService<ApplicationRoleManager>();
Assert.Equal(userStore, userStore2);
Assert.NotEqual(userManager, userManager2);
Assert.Equal(roleStore, roleStore2);
Assert.NotEqual(roleManager, roleManager2);
}
private static async Task CreateAdminUser(IServiceProvider serviceProvider)
{
const string userName = "admin";