Add support for UserClaims

src/Microsoft.AspNet.Identity.Entity/IdentitySqlContext.cs

@@ -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");
         }
     }
 }

src/Microsoft.AspNet.Identity.Entity/SqlUserStore.cs

@@ -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);
+        }
     }
 }

src/Microsoft.AspNet.Identity.InMemory/IdentityBuilderExtensions.cs

@@ -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;
         }

test/Microsoft.AspNet.Identity.Entity.Test/SqlUserStoreTest.cs

@@ -214,8 +214,8 @@ namespace Microsoft.AspNet.Identity.Entity.Test
         [Fact]
         public async Task CanChangePassword()
         {
-            var manager = TestIdentityFactory.CreateManager();
+            var manager = CreateManager();
-            var user = new EntityUser("ChangePasswordTest");
+            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));
+        }
     }
 }

test/Microsoft.AspNet.Identity.InMemory.Test/StartupTest.cs

@@ -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";