Improvements on EF Core mapping for Identity and IdentityServer

src/AbpDesk/AbpDesk.EntityFrameworkCore/AbpDesk/EntityFrameworkCore/AbpDeskDbContext.cs

@@ -26,7 +26,7 @@ namespace AbpDesk.EntityFrameworkCore
         {
             base.OnModelCreating(modelBuilder);
 
-            this.ConfigureAbpMultiTenancy(modelBuilder);
+            this.ConfigureMultiTenancy(modelBuilder);
 
             //Use different classes to map each entity type?
             modelBuilder.Entity<Ticket>(b =>

src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUser.cs

@@ -253,12 +253,9 @@ namespace Volo.Abp.Identity
             Tokens.RemoveAll(t => t.LoginProvider == loginProvider && t.Name == name);
         }
 
-        /// <summary>
-        /// Returns the username for this user.
-        /// </summary>
         public override string ToString()
         {
-            return $"{base.ToString()} UserName = {UserName}";
+            return $"{base.ToString()}, UserName = {UserName}";
         }
     }
 }

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EfCoreIdentityRoleRepository.cs

@@ -11,9 +11,9 @@ using System;
 
 namespace Volo.Abp.Identity
 {
-    public class EfCoreIdentityRoleRepository : EfCoreRepository<IdentityDbContext, IdentityRole, Guid>, IIdentityRoleRepository
+    public class EfCoreIdentityRoleRepository : EfCoreRepository<IIdentityDbContext, IdentityRole, Guid>, IIdentityRoleRepository
     {
-        public EfCoreIdentityRoleRepository(IDbContextProvider<IdentityDbContext> dbContextProvider)
+        public EfCoreIdentityRoleRepository(IDbContextProvider<IIdentityDbContext> dbContextProvider)
             : base(dbContextProvider)
         {
         }

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EfCoreIdentityUserRepository.cs

@@ -12,9 +12,9 @@ using Volo.Abp.Identity.EntityFrameworkCore;
 
 namespace Volo.Abp.Identity
 {
-    public class EfCoreIdentityUserRepository : EfCoreRepository<IdentityDbContext, IdentityUser, Guid>, IIdentityUserRepository
+    public class EfCoreIdentityUserRepository : EfCoreRepository<IIdentityDbContext, IdentityUser, Guid>, IIdentityUserRepository
     {
-        public EfCoreIdentityUserRepository(IDbContextProvider<IdentityDbContext> dbContextProvider)
+        public EfCoreIdentityUserRepository(IDbContextProvider<IIdentityDbContext> dbContextProvider)
             : base(dbContextProvider)
         {
         }

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EntityFrameworkCore/AbpIdentityEntityFrameworkCoreModule.cs

@@ -11,7 +11,7 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
         {
             services.AddAbpDbContext<IdentityDbContext>(options =>
             {
-                options.AddDefaultRepositories();
+                options.AddDefaultRepositories<IIdentityDbContext>();
                 options.AddRepository<IdentityUser, EfCoreIdentityUserRepository>();
                 options.AddRepository<IdentityRole, EfCoreIdentityRoleRepository>();
             });

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EntityFrameworkCore/IIdentityDbContext.cs

@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+namespace Volo.Abp.Identity.EntityFrameworkCore
+{
+    public interface IIdentityDbContext : IEfCoreDbContext
+    {
+        DbSet<IdentityUser> Users { get; set; }
+
+        DbSet<IdentityUserClaim> UserClaims { get; set; }
+
+        DbSet<IdentityUserLogin> UserLogins { get; set; }
+
+        DbSet<IdentityUserRole> UserRoles { get; set; }
+
+        DbSet<IdentityUserToken> UserTokens { get; set; }
+
+        DbSet<IdentityRole> Roles { get; set; }
+
+        DbSet<IdentityRoleClaim> RoleClaims { get; set; }
+    }
+}

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EntityFrameworkCore/IdentityDbContext.cs

@@ -6,17 +6,11 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
     /// <summary>
     /// Base class for the Entity Framework database context used for identity.
     /// </summary>
-    public class IdentityDbContext : AbpDbContext<IdentityDbContext>
+    public class IdentityDbContext : AbpDbContext<IdentityDbContext>, IIdentityDbContext
     {
-        /// <summary>
+        public static string TablePrefix { get; set; } = "Identity";
-        /// Initializes a new instance of <see cref="IdentityDbContext"/>.
+
-        /// </summary>
+        public static string Schema { get; set; }
-        /// <param name="options">The options to be used by a <see cref="DbContext"/>.</param>
-        public IdentityDbContext(DbContextOptions<IdentityDbContext> options)
-            : base(options)
-        {
-            
-        }
 
         /// <summary>
         /// Gets or sets the <see cref="DbSet{TEntity}"/> of Users.
@@ -53,6 +47,16 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
         /// </summary>
         public DbSet<IdentityRoleClaim> RoleClaims { get; set; }
 
+        /// <summary>
+        /// Initializes a new instance of <see cref="IdentityDbContext"/>.
+        /// </summary>
+        /// <param name="options">The options to be used by a <see cref="DbContext"/>.</param>
+        public IdentityDbContext(DbContextOptions<IdentityDbContext> options)
+            : base(options)
+        {
+
+        }
+
         /// <summary>
         /// Configures the schema needed for the identity framework.
         /// </summary>
@@ -63,98 +67,7 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
         {
             base.OnModelCreating(builder);
 
-            //TODO: Split configuration to dedicated classes (probably a resuable extension method)
+            this.ConfigureIdentity(builder, TablePrefix, Schema);
-
-            builder.Entity<IdentityUser>(b =>
-            {
-                b.ToTable("IdentityUsers"); //TODO: Make all table and schema names changeable
-
-                b.Property(u => u.UserName).IsRequired().HasMaxLength(IdentityUserConsts.MaxUserNameLength);
-                b.Property(u => u.NormalizedUserName).IsRequired().HasMaxLength(IdentityUserConsts.MaxNormalizedUserNameLength);
-                b.Property(u => u.Email).HasMaxLength(IdentityUserConsts.MaxEmailLength);
-                b.Property(u => u.NormalizedEmail).HasMaxLength(IdentityUserConsts.MaxNormalizedEmailLength);
-                b.Property(u => u.PhoneNumber).HasMaxLength(IdentityUserConsts.MaxPhoneNumberLength);
-                b.Property(u => u.PasswordHash).HasMaxLength(IdentityUserConsts.MaxPasswordHashLength);
-                b.Property(u => u.SecurityStamp).IsRequired().HasMaxLength(IdentityUserConsts.MaxSecurityStampLength);
-                b.Property(u => u.ConcurrencyStamp).IsRequired().HasMaxLength(IdentityUserConsts.MaxConcurrencyStampLength);
-                b.Property(u => u.EmailConfirmed).HasDefaultValue(false);
-                b.Property(u => u.PhoneNumberConfirmed).HasDefaultValue(false);
-                b.Property(u => u.TwoFactorEnabled).HasDefaultValue(false);
-                b.Property(u => u.LockoutEnabled).HasDefaultValue(false);
-                b.Property(u => u.AccessFailedCount).HasDefaultValue(0);
-
-                b.HasMany(u => u.Claims).WithOne().HasForeignKey(uc => uc.UserId).IsRequired();
-                b.HasMany(u => u.Logins).WithOne().HasForeignKey(ul => ul.UserId).IsRequired();
-                b.HasMany(u => u.Roles).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
-                b.HasMany(u => u.Tokens).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
-
-                b.HasIndex(u => u.NormalizedUserName);
-                b.HasIndex(u => u.NormalizedEmail);
-            });
-
-            builder.Entity<IdentityRole>(b =>
-            {
-                b.ToTable("IdentityRoles");
-
-                b.Property(r => r.Name).IsRequired().HasMaxLength(IdentityRoleConsts.MaxNameLength);
-                b.Property(r => r.NormalizedName).IsRequired().HasMaxLength(IdentityRoleConsts.MaxNormalizedNameLength);
-
-                b.HasMany(r => r.Claims).WithOne().HasForeignKey(rc => rc.RoleId).IsRequired();
-
-                b.HasIndex(r => r.NormalizedName);
-            });
-
-            builder.Entity<IdentityUserClaim>(b => 
-            {
-                b.ToTable("IdentityUserClaims");
-
-                b.Property(uc => uc.ClaimType).HasMaxLength(IdentityUserClaimConsts.MaxClaimTypeLength).IsRequired();
-                b.Property(uc => uc.ClaimValue).HasMaxLength(IdentityUserClaimConsts.MaxClaimValueLength);
-
-                b.HasIndex(uc => uc.UserId);
-            });
-
-            builder.Entity<IdentityRoleClaim>(b => 
-            {
-                b.ToTable("IdentityRoleClaims");
-
-                b.Property(uc => uc.ClaimType).HasMaxLength(IdentityRoleClaimConsts.MaxClaimTypeLength).IsRequired();
-                b.Property(uc => uc.ClaimValue).HasMaxLength(IdentityRoleClaimConsts.MaxClaimValueLength);
-
-                b.HasIndex(uc => uc.RoleId);
-            });
-
-            builder.Entity<IdentityUserRole>(b => 
-            {
-                b.ToTable("IdentityUserRoles");
-
-                b.HasOne<IdentityRole>().WithMany().HasForeignKey(ur => ur.RoleId).IsRequired();
-                b.HasOne<IdentityUser>().WithMany(u => u.Roles).HasForeignKey(ur => ur.UserId).IsRequired();
-
-                b.HasIndex(ur => new { ur.UserId, ur.RoleId });
-                b.HasIndex(ur => new { ur.RoleId, ur.UserId });
-            });
-
-            builder.Entity<IdentityUserLogin>(b =>
-            {
-                b.ToTable("IdentityUserLogins");
-
-                b.Property(ul => ul.LoginProvider).HasMaxLength(IdentityUserLoginConsts.MaxLoginProviderLength).IsRequired();
-                b.Property(ul => ul.ProviderKey).HasMaxLength(IdentityUserLoginConsts.MaxProviderKeyLength).IsRequired();
-                b.Property(ul => ul.ProviderDisplayName).HasMaxLength(IdentityUserLoginConsts.MaxProviderDisplayNameLength);
-
-                b.HasIndex(l => new { l.UserId, l.LoginProvider, l.ProviderKey });
-                b.HasIndex(l => new { l.LoginProvider, l.ProviderKey });
-            });
-
-            builder.Entity<IdentityUserToken>(b => 
-            {
-                b.ToTable("IdentityUserTokens");
-
-                b.Property(ul => ul.LoginProvider).HasMaxLength(IdentityUserTokenConsts.MaxLoginProviderLength).IsRequired();
-
-                b.HasIndex(l => new { l.UserId, l.LoginProvider, l.Name });
-            });
         }
     }
 }

src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EntityFrameworkCore/IdentityDbContextModelBuilderExtensions.cs

@@ -0,0 +1,108 @@
+using System;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace Volo.Abp.Identity.EntityFrameworkCore
+{
+    public static class IdentityDbContextModelBuilderExtensions
+    {
+        public static void ConfigureIdentity(this IIdentityDbContext dbContext, ModelBuilder builder, string tablePrefix = "", [CanBeNull] string schema = null)
+        {
+            if (tablePrefix.IsNullOrWhiteSpace())
+            {
+                tablePrefix = "";
+            }
+
+            builder.Entity<IdentityUser>(b =>
+            {
+                b.ToTable(tablePrefix + "Users", schema);
+
+                b.Property(u => u.UserName).IsRequired().HasMaxLength(IdentityUserConsts.MaxUserNameLength);
+                b.Property(u => u.NormalizedUserName).IsRequired().HasMaxLength(IdentityUserConsts.MaxNormalizedUserNameLength);
+                b.Property(u => u.Email).HasMaxLength(IdentityUserConsts.MaxEmailLength);
+                b.Property(u => u.NormalizedEmail).HasMaxLength(IdentityUserConsts.MaxNormalizedEmailLength);
+                b.Property(u => u.PhoneNumber).HasMaxLength(IdentityUserConsts.MaxPhoneNumberLength);
+                b.Property(u => u.PasswordHash).HasMaxLength(IdentityUserConsts.MaxPasswordHashLength);
+                b.Property(u => u.SecurityStamp).IsRequired().HasMaxLength(IdentityUserConsts.MaxSecurityStampLength);
+                b.Property(u => u.ConcurrencyStamp).IsRequired().HasMaxLength(IdentityUserConsts.MaxConcurrencyStampLength);
+                b.Property(u => u.EmailConfirmed).HasDefaultValue(false);
+                b.Property(u => u.PhoneNumberConfirmed).HasDefaultValue(false);
+                b.Property(u => u.TwoFactorEnabled).HasDefaultValue(false);
+                b.Property(u => u.LockoutEnabled).HasDefaultValue(false);
+                b.Property(u => u.AccessFailedCount).HasDefaultValue(0);
+
+                b.HasMany(u => u.Claims).WithOne().HasForeignKey(uc => uc.UserId).IsRequired();
+                b.HasMany(u => u.Logins).WithOne().HasForeignKey(ul => ul.UserId).IsRequired();
+                b.HasMany(u => u.Roles).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
+                b.HasMany(u => u.Tokens).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
+
+                b.HasIndex(u => u.NormalizedUserName);
+                b.HasIndex(u => u.NormalizedEmail);
+            });
+
+            builder.Entity<IdentityRole>(b =>
+            {
+                b.ToTable(tablePrefix + "Roles", schema);
+
+                b.Property(r => r.Name).IsRequired().HasMaxLength(IdentityRoleConsts.MaxNameLength);
+                b.Property(r => r.NormalizedName).IsRequired().HasMaxLength(IdentityRoleConsts.MaxNormalizedNameLength);
+
+                b.HasMany(r => r.Claims).WithOne().HasForeignKey(rc => rc.RoleId).IsRequired();
+
+                b.HasIndex(r => r.NormalizedName);
+            });
+
+            builder.Entity<IdentityUserClaim>(b =>
+            {
+                b.ToTable(tablePrefix + "UserClaims", schema);
+
+                b.Property(uc => uc.ClaimType).HasMaxLength(IdentityUserClaimConsts.MaxClaimTypeLength).IsRequired();
+                b.Property(uc => uc.ClaimValue).HasMaxLength(IdentityUserClaimConsts.MaxClaimValueLength);
+
+                b.HasIndex(uc => uc.UserId);
+            });
+
+            builder.Entity<IdentityRoleClaim>(b =>
+            {
+                b.ToTable(tablePrefix + "RoleClaims", schema);
+
+                b.Property(uc => uc.ClaimType).HasMaxLength(IdentityRoleClaimConsts.MaxClaimTypeLength).IsRequired();
+                b.Property(uc => uc.ClaimValue).HasMaxLength(IdentityRoleClaimConsts.MaxClaimValueLength);
+
+                b.HasIndex(uc => uc.RoleId);
+            });
+
+            builder.Entity<IdentityUserRole>(b =>
+            {
+                b.ToTable(tablePrefix + "UserRoles", schema);
+
+                b.HasOne<IdentityRole>().WithMany().HasForeignKey(ur => ur.RoleId).IsRequired();
+                b.HasOne<IdentityUser>().WithMany(u => u.Roles).HasForeignKey(ur => ur.UserId).IsRequired();
+
+                b.HasIndex(ur => new { ur.UserId, ur.RoleId });
+                b.HasIndex(ur => new { ur.RoleId, ur.UserId });
+            });
+
+            builder.Entity<IdentityUserLogin>(b =>
+            {
+                b.ToTable(tablePrefix + "UserLogins", schema);
+
+                b.Property(ul => ul.LoginProvider).HasMaxLength(IdentityUserLoginConsts.MaxLoginProviderLength).IsRequired();
+                b.Property(ul => ul.ProviderKey).HasMaxLength(IdentityUserLoginConsts.MaxProviderKeyLength).IsRequired();
+                b.Property(ul => ul.ProviderDisplayName).HasMaxLength(IdentityUserLoginConsts.MaxProviderDisplayNameLength);
+
+                b.HasIndex(l => new { l.UserId, l.LoginProvider, l.ProviderKey });
+                b.HasIndex(l => new { l.LoginProvider, l.ProviderKey });
+            });
+
+            builder.Entity<IdentityUserToken>(b =>
+            {
+                b.ToTable(tablePrefix + "UserTokens", schema);
+
+                b.Property(ul => ul.LoginProvider).HasMaxLength(IdentityUserTokenConsts.MaxLoginProviderLength).IsRequired();
+
+                b.HasIndex(l => new { l.UserId, l.LoginProvider, l.Name });
+            });
+        }
+    }
+}

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/ApiResourceRepository.cs

@@ -9,9 +9,9 @@ using Volo.Abp.IdentityServer.EntityFrameworkCore;
 
 namespace Volo.Abp.IdentityServer
 {
-    public class ApiResourceRepository : EfCoreRepository<IdentityServerDbContext, ApiResource, Guid>, IApiResourceRepository
+    public class ApiResourceRepository : EfCoreRepository<IIdentityServerDbContext, ApiResource, Guid>, IApiResourceRepository
     {
-        public ApiResourceRepository(IDbContextProvider<IdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
+        public ApiResourceRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
         {
 
         }

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/ClientRepository.cs

@@ -8,9 +8,9 @@ using Volo.Abp.IdentityServer.EntityFrameworkCore;
 
 namespace Volo.Abp.IdentityServer
 {
-    public class ClientRepository : EfCoreRepository<IdentityServerDbContext, Client, Guid>, IClientRepository
+    public class ClientRepository : EfCoreRepository<IIdentityServerDbContext, Client, Guid>, IClientRepository
     {
-        public ClientRepository(IDbContextProvider<IdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
+        public ClientRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
         {
 
         }

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/EntityFrameworkCore/AbpIdentityServerEntityFrameworkCoreModule.cs

@@ -13,7 +13,7 @@ namespace Volo.Abp.IdentityServer.EntityFrameworkCore
         {
             services.AddAbpDbContext<IdentityServerDbContext>(options =>
             {
-                options.AddDefaultRepositories();
+                options.AddDefaultRepositories<IIdentityServerDbContext>();
                 options.AddRepository<Client, ClientRepository>();
             });
 

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/EntityFrameworkCore/IIdentityServerDbContext.cs

@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.IdentityServer.ApiResources;
+using Volo.Abp.IdentityServer.Clients;
+using Volo.Abp.IdentityServer.Grants;
+using Volo.Abp.IdentityServer.IdentityResources;
+
+namespace Volo.Abp.IdentityServer.EntityFrameworkCore
+{
+    public interface IIdentityServerDbContext : IEfCoreDbContext
+    {
+        DbSet<ApiResource> ApiResources { get; set; }
+
+        DbSet<ApiSecret> ApiSecrets { get; set; }
+
+        DbSet<ApiResourceClaim> ApiResourceClaims { get; set; }
+
+        DbSet<ApiScope> ApiScopes { get; set; }
+
+        DbSet<ApiScopeClaim> ApiScopeClaims { get; set; }
+
+        DbSet<IdentityResource> IdentityResources { get; set; }
+
+        DbSet<IdentityClaim> IdentityClaims { get; set; }
+
+        DbSet<Client> Clients { get; set; }
+
+        DbSet<ClientGrantType> ClientGrantTypes { get; set; }
+
+        DbSet<ClientRedirectUri> ClientRedirectUris { get; set; }
+
+        DbSet<ClientPostLogoutRedirectUri> ClientPostLogoutRedirectUris { get; set; }
+
+        DbSet<ClientScope> ClientScopes { get; set; }
+
+        DbSet<ClientSecret> ClientSecrets { get; set; }
+
+        DbSet<ClientClaim> ClientClaims { get; set; }
+
+        DbSet<ClientIdPRestriction> ClientIdPRestrictions { get; set; }
+
+        DbSet<ClientCorsOrigin> ClientCorsOrigins { get; set; }
+
+        DbSet<ClientProperty> ClientProperties { get; set; }
+
+        DbSet<PersistedGrant> PersistedGrants { get; set; }
+    }
+}

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/EntityFrameworkCore/IdentityServerDbContext.cs

@@ -7,9 +7,11 @@ using Volo.Abp.IdentityServer.IdentityResources;
 
 namespace Volo.Abp.IdentityServer.EntityFrameworkCore
 {
-    public class IdentityServerDbContext : AbpDbContext<IdentityServerDbContext>
+    public class IdentityServerDbContext : AbpDbContext<IdentityServerDbContext>, IIdentityServerDbContext
     {
-        public const string TablePrefix = "IdentityServer"; //TODO: Make configurable
+        public static string TablePrefix { get; set; } = "IdentityServer";
+
+        public static string Schema { get; set; }
 
         public DbSet<ApiResource> ApiResources { get; set; }
 
@@ -57,208 +59,7 @@ namespace Volo.Abp.IdentityServer.EntityFrameworkCore
         {
             base.OnModelCreating(builder);
 
-            builder.Entity<Client>(client =>
+            this.ConfigureIdentityServer(builder, TablePrefix, Schema);
-            {
-                client.ToTable(TablePrefix + "Clients");
-
-                client.Property(x => x.ClientId).HasMaxLength(ClientConsts.ClientIdMaxLength).IsRequired();
-                client.Property(x => x.ProtocolType).HasMaxLength(ClientConsts.ProtocolTypeMaxLength).IsRequired();
-                client.Property(x => x.ClientName).HasMaxLength(ClientConsts.ClientNameMaxLength);
-                client.Property(x => x.ClientUri).HasMaxLength(ClientConsts.ClientUriMaxLength);
-                client.Property(x => x.LogoUri).HasMaxLength(ClientConsts.LogoUriMaxLength);
-                client.Property(x => x.Description).HasMaxLength(ClientConsts.DescriptionMaxLength);
-                client.Property(x => x.FrontChannelLogoutUri).HasMaxLength(ClientConsts.FrontChannelLogoutUriMaxLength);
-                client.Property(x => x.BackChannelLogoutUri).HasMaxLength(ClientConsts.BackChannelLogoutUriMaxLength);
-                client.Property(x => x.ClientClaimsPrefix).HasMaxLength(ClientConsts.ClientClaimsPrefixMaxLength);
-                client.Property(x => x.PairWiseSubjectSalt).HasMaxLength(ClientConsts.PairWiseSubjectSaltMaxLength);
-
-                client.HasMany(x => x.AllowedScopes).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.ClientSecrets).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.AllowedGrantTypes).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.AllowedCorsOrigins).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.RedirectUris).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.PostLogoutRedirectUris).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.IdentityProviderRestrictions).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.Claims).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-                client.HasMany(x => x.Properties).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
-
-                client.HasIndex(x => x.ClientId).IsUnique();
-            });
-
-            builder.Entity<ClientGrantType>(grantType =>
-            {
-                grantType.ToTable(TablePrefix + "ClientGrantTypes");
-
-                grantType.HasKey(x => new {x.ClientId, x.GrantType});
-
-                grantType.Property(x => x.GrantType).HasMaxLength(ClientGrantTypeConsts.GrantTypeMaxLength).IsRequired();
-            });
-            
-            builder.Entity<ClientRedirectUri>(redirectUri =>
-            {
-                redirectUri.ToTable(TablePrefix + "ClientRedirectUris");
-
-                redirectUri.HasKey(x => new {x.ClientId, x.RedirectUri});
-
-                redirectUri.Property(x => x.RedirectUri).HasMaxLength(ClientRedirectUriConsts.RedirectUriMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientPostLogoutRedirectUri>(postLogoutRedirectUri =>
-            {
-                postLogoutRedirectUri.ToTable(TablePrefix + "ClientPostLogoutRedirectUris");
-
-                postLogoutRedirectUri.HasKey(x => new {x.ClientId, x.PostLogoutRedirectUri});
-
-                postLogoutRedirectUri.Property(x => x.PostLogoutRedirectUri).HasMaxLength(ClientPostLogoutRedirectUriConsts.PostLogoutRedirectUriMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientScope>(scope =>
-            {
-                scope.ToTable(TablePrefix + "ClientScopes");
-
-                scope.HasKey(x => new {x.ClientId, x.Scope});
-
-                scope.Property(x => x.Scope).HasMaxLength(ClientScopeConsts.ScopeMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientSecret>(secret =>
-            {
-                secret.ToTable(TablePrefix + "ClientSecrets");
-
-                secret.HasKey(x => new { x.ClientId, x.Type, x.Value });
-
-                secret.Property(x => x.Type).HasMaxLength(SecretConsts.TypeMaxLength).IsRequired();
-                secret.Property(x => x.Value).HasMaxLength(SecretConsts.ValueMaxLength).IsRequired();
-                secret.Property(x => x.Description).HasMaxLength(SecretConsts.DescriptionMaxLength);
-            });
-
-            builder.Entity<ClientClaim>(claim =>
-            {
-                claim.ToTable(TablePrefix + "ClientClaims");
-
-                claim.Property(x => x.Type).HasMaxLength(ClientClaimConsts.TypeMaxLength).IsRequired();
-                claim.Property(x => x.Value).HasMaxLength(ClientClaimConsts.ValueMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientIdPRestriction>(idPRestriction =>
-            {
-                idPRestriction.ToTable(TablePrefix + "ClientIdPRestrictions");
-
-                idPRestriction.HasKey(x => new {x.ClientId, x.Provider});
-
-                idPRestriction.Property(x => x.Provider).HasMaxLength(ClientIdPRestrictionConsts.ProviderMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientCorsOrigin>(corsOrigin =>
-            {
-                corsOrigin.ToTable(TablePrefix + "ClientCorsOrigins");
-
-                corsOrigin.HasKey(x => new {x.ClientId, x.Origin});
-
-                corsOrigin.Property(x => x.Origin).HasMaxLength(ClientCorsOriginConsts.OriginMaxLength).IsRequired();
-            });
-
-            builder.Entity<ClientProperty>(property =>
-            {
-                property.ToTable(TablePrefix + "ClientProperties");
-
-                property.HasKey(x => new {x.ClientId, x.Key});
-
-                property.Property(x => x.Key).HasMaxLength(ClientPropertyConsts.KeyMaxLength).IsRequired();
-                property.Property(x => x.Value).HasMaxLength(ClientPropertyConsts.ValueMaxLength).IsRequired();
-            });
-
-            builder.Entity<PersistedGrant>(grant =>
-            {
-                grant.ToTable(TablePrefix + "PersistedGrants");
-
-                grant.Property(x => x.Key).HasMaxLength(PersistedGrantConsts.KeyMaxLength).ValueGeneratedNever();
-                grant.Property(x => x.Type).HasMaxLength(PersistedGrantConsts.TypeMaxLength).IsRequired();
-                grant.Property(x => x.SubjectId).HasMaxLength(PersistedGrantConsts.SubjectIdMaxLength);
-                grant.Property(x => x.ClientId).HasMaxLength(PersistedGrantConsts.ClientIdMaxLength).IsRequired();
-                grant.Property(x => x.CreationTime).IsRequired();
-                grant.Property(x => x.Data).IsRequired();
-
-                grant.HasKey(x => x.Key); //TODO: What about Id!!!
-
-                grant.HasIndex(x => new { x.SubjectId, x.ClientId, x.Type });
-            });
-
-            builder.Entity<IdentityResource>(identityResource =>
-            {
-                identityResource.ToTable(TablePrefix + "IdentityResources");
-
-                identityResource.Property(x => x.Name).HasMaxLength(IdentityResourceConsts.NameMaxLength).IsRequired();
-                identityResource.Property(x => x.DisplayName).HasMaxLength(IdentityResourceConsts.DisplayNameMaxLength);
-                identityResource.Property(x => x.Description).HasMaxLength(IdentityResourceConsts.DescriptionMaxLength);
-
-                identityResource.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => x.IdentityResourceId).IsRequired();
-            });
-
-            builder.Entity<IdentityClaim>(claim =>
-            {
-                claim.ToTable(TablePrefix + "IdentityClaims");
-
-                claim.HasKey(x => new {x.IdentityResourceId, x.Type});
-
-                claim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
-            });
-
-            builder.Entity<ApiResource>(apiResource =>
-            {
-                apiResource.ToTable(TablePrefix + "ApiResources");
-
-                apiResource.Property(x => x.Name).HasMaxLength(ApiResourceConsts.NameMaxLength).IsRequired();
-                apiResource.Property(x => x.DisplayName).HasMaxLength(ApiResourceConsts.DisplayNameMaxLength);
-                apiResource.Property(x => x.Description).HasMaxLength(ApiResourceConsts.DescriptionMaxLength);
-
-                apiResource.HasMany(x => x.Secrets).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
-                apiResource.HasMany(x => x.Scopes).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
-                apiResource.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
-            });
-
-            builder.Entity<ApiSecret>(apiSecret =>
-            {
-                apiSecret.ToTable(TablePrefix + "ApiSecrets");
-
-                apiSecret.HasKey(x => new { x.ApiResourceId, x.Type, x.Value });
-
-                apiSecret.Property(x => x.Type).HasMaxLength(SecretConsts.TypeMaxLength).IsRequired();
-                apiSecret.Property(x => x.Value).HasMaxLength(SecretConsts.ValueMaxLength).IsRequired();
-                apiSecret.Property(x => x.Description).HasMaxLength(SecretConsts.DescriptionMaxLength);
-            });
-
-            builder.Entity<ApiResourceClaim>(apiClaim =>
-            {
-                apiClaim.ToTable(TablePrefix + "ApiClaims");
-
-                apiClaim.HasKey(x => new {x.ApiResourceId, x.Type});
-
-                apiClaim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
-            });
-
-            builder.Entity<ApiScope>(apiScope =>
-            {
-                apiScope.ToTable(TablePrefix + "ApiScopes");
-
-                apiScope.HasKey(x => new { x.ApiResourceId, x.Name });
-
-                apiScope.Property(x => x.Name).HasMaxLength(ApiScopeConsts.NameMaxLength).IsRequired();
-                apiScope.Property(x => x.DisplayName).HasMaxLength(ApiScopeConsts.DisplayNameMaxLength);
-                apiScope.Property(x => x.Description).HasMaxLength(ApiScopeConsts.DescriptionMaxLength);
-
-                apiScope.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => new { x.ApiResourceId, x.Name }).IsRequired();
-            });
-
-            builder.Entity<ApiScopeClaim>(apiScopeClaim =>
-            {
-                apiScopeClaim.ToTable(TablePrefix + "ApiScopeClaims");
-
-                apiScopeClaim.HasKey(x => new {x.ApiResourceId, x.Name, x.Type});
-
-                apiScopeClaim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
-                apiScopeClaim.Property(x => x.Name).HasMaxLength(ApiScopeConsts.NameMaxLength).IsRequired();
-            });
         }
     }
 }

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/EntityFrameworkCore/IdentityServerDbContextModelCreatingExtensions.cs

@@ -0,0 +1,224 @@
+using System;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.IdentityServer.ApiResources;
+using Volo.Abp.IdentityServer.Clients;
+using Volo.Abp.IdentityServer.Grants;
+using Volo.Abp.IdentityServer.IdentityResources;
+
+namespace Volo.Abp.IdentityServer.EntityFrameworkCore
+{
+    public static class IdentityServerDbContextModelCreatingExtensions
+    {
+        public static void ConfigureIdentityServer(this IIdentityServerDbContext dbContext, ModelBuilder builder, string tablePrefix = "", [CanBeNull] string schema = null)
+        {
+            if (tablePrefix.IsNullOrWhiteSpace())
+            {
+                tablePrefix = "";
+            }
+
+            builder.Entity<Client>(client =>
+            {
+                client.ToTable(tablePrefix + "Clients", schema);
+
+                client.Property(x => x.ClientId).HasMaxLength(ClientConsts.ClientIdMaxLength).IsRequired();
+                client.Property(x => x.ProtocolType).HasMaxLength(ClientConsts.ProtocolTypeMaxLength).IsRequired();
+                client.Property(x => x.ClientName).HasMaxLength(ClientConsts.ClientNameMaxLength);
+                client.Property(x => x.ClientUri).HasMaxLength(ClientConsts.ClientUriMaxLength);
+                client.Property(x => x.LogoUri).HasMaxLength(ClientConsts.LogoUriMaxLength);
+                client.Property(x => x.Description).HasMaxLength(ClientConsts.DescriptionMaxLength);
+                client.Property(x => x.FrontChannelLogoutUri).HasMaxLength(ClientConsts.FrontChannelLogoutUriMaxLength);
+                client.Property(x => x.BackChannelLogoutUri).HasMaxLength(ClientConsts.BackChannelLogoutUriMaxLength);
+                client.Property(x => x.ClientClaimsPrefix).HasMaxLength(ClientConsts.ClientClaimsPrefixMaxLength);
+                client.Property(x => x.PairWiseSubjectSalt).HasMaxLength(ClientConsts.PairWiseSubjectSaltMaxLength);
+
+                client.HasMany(x => x.AllowedScopes).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.ClientSecrets).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.AllowedGrantTypes).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.AllowedCorsOrigins).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.RedirectUris).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.PostLogoutRedirectUris).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.IdentityProviderRestrictions).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.Claims).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+                client.HasMany(x => x.Properties).WithOne().HasForeignKey(x => x.ClientId).IsRequired();
+
+                client.HasIndex(x => x.ClientId).IsUnique();
+            });
+
+            builder.Entity<ClientGrantType>(grantType =>
+            {
+                grantType.ToTable(tablePrefix + "ClientGrantTypes", schema);
+
+                grantType.HasKey(x => new { x.ClientId, x.GrantType });
+
+                grantType.Property(x => x.GrantType).HasMaxLength(ClientGrantTypeConsts.GrantTypeMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientRedirectUri>(redirectUri =>
+            {
+                redirectUri.ToTable(tablePrefix + "ClientRedirectUris", schema);
+
+                redirectUri.HasKey(x => new { x.ClientId, x.RedirectUri });
+
+                redirectUri.Property(x => x.RedirectUri).HasMaxLength(ClientRedirectUriConsts.RedirectUriMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientPostLogoutRedirectUri>(postLogoutRedirectUri =>
+            {
+                postLogoutRedirectUri.ToTable(tablePrefix + "ClientPostLogoutRedirectUris", schema);
+
+                postLogoutRedirectUri.HasKey(x => new { x.ClientId, x.PostLogoutRedirectUri });
+
+                postLogoutRedirectUri.Property(x => x.PostLogoutRedirectUri).HasMaxLength(ClientPostLogoutRedirectUriConsts.PostLogoutRedirectUriMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientScope>(scope =>
+            {
+                scope.ToTable(tablePrefix + "ClientScopes", schema);
+
+                scope.HasKey(x => new { x.ClientId, x.Scope });
+
+                scope.Property(x => x.Scope).HasMaxLength(ClientScopeConsts.ScopeMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientSecret>(secret =>
+            {
+                secret.ToTable(tablePrefix + "ClientSecrets", schema);
+
+                secret.HasKey(x => new { x.ClientId, x.Type, x.Value });
+
+                secret.Property(x => x.Type).HasMaxLength(SecretConsts.TypeMaxLength).IsRequired();
+                secret.Property(x => x.Value).HasMaxLength(SecretConsts.ValueMaxLength).IsRequired();
+                secret.Property(x => x.Description).HasMaxLength(SecretConsts.DescriptionMaxLength);
+            });
+
+            builder.Entity<ClientClaim>(claim =>
+            {
+                claim.ToTable(tablePrefix + "ClientClaims", schema);
+
+                claim.Property(x => x.Type).HasMaxLength(ClientClaimConsts.TypeMaxLength).IsRequired();
+                claim.Property(x => x.Value).HasMaxLength(ClientClaimConsts.ValueMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientIdPRestriction>(idPRestriction =>
+            {
+                idPRestriction.ToTable(tablePrefix + "ClientIdPRestrictions", schema);
+
+                idPRestriction.HasKey(x => new { x.ClientId, x.Provider });
+
+                idPRestriction.Property(x => x.Provider).HasMaxLength(ClientIdPRestrictionConsts.ProviderMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientCorsOrigin>(corsOrigin =>
+            {
+                corsOrigin.ToTable(tablePrefix + "ClientCorsOrigins", schema);
+
+                corsOrigin.HasKey(x => new { x.ClientId, x.Origin });
+
+                corsOrigin.Property(x => x.Origin).HasMaxLength(ClientCorsOriginConsts.OriginMaxLength).IsRequired();
+            });
+
+            builder.Entity<ClientProperty>(property =>
+            {
+                property.ToTable(tablePrefix + "ClientProperties", schema);
+
+                property.HasKey(x => new { x.ClientId, x.Key });
+
+                property.Property(x => x.Key).HasMaxLength(ClientPropertyConsts.KeyMaxLength).IsRequired();
+                property.Property(x => x.Value).HasMaxLength(ClientPropertyConsts.ValueMaxLength).IsRequired();
+            });
+
+            builder.Entity<PersistedGrant>(grant =>
+            {
+                grant.ToTable(tablePrefix + "PersistedGrants", schema);
+
+                grant.Property(x => x.Key).HasMaxLength(PersistedGrantConsts.KeyMaxLength).ValueGeneratedNever();
+                grant.Property(x => x.Type).HasMaxLength(PersistedGrantConsts.TypeMaxLength).IsRequired();
+                grant.Property(x => x.SubjectId).HasMaxLength(PersistedGrantConsts.SubjectIdMaxLength);
+                grant.Property(x => x.ClientId).HasMaxLength(PersistedGrantConsts.ClientIdMaxLength).IsRequired();
+                grant.Property(x => x.CreationTime).IsRequired();
+                grant.Property(x => x.Data).IsRequired();
+
+                grant.HasKey(x => x.Key); //TODO: What about Id!!!
+
+                grant.HasIndex(x => new { x.SubjectId, x.ClientId, x.Type });
+            });
+
+            builder.Entity<IdentityResource>(identityResource =>
+            {
+                identityResource.ToTable(tablePrefix + "IdentityResources", schema);
+
+                identityResource.Property(x => x.Name).HasMaxLength(IdentityResourceConsts.NameMaxLength).IsRequired();
+                identityResource.Property(x => x.DisplayName).HasMaxLength(IdentityResourceConsts.DisplayNameMaxLength);
+                identityResource.Property(x => x.Description).HasMaxLength(IdentityResourceConsts.DescriptionMaxLength);
+
+                identityResource.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => x.IdentityResourceId).IsRequired();
+            });
+
+            builder.Entity<IdentityClaim>(claim =>
+            {
+                claim.ToTable(tablePrefix + "IdentityClaims", schema);
+
+                claim.HasKey(x => new { x.IdentityResourceId, x.Type });
+
+                claim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
+            });
+
+            builder.Entity<ApiResource>(apiResource =>
+            {
+                apiResource.ToTable(tablePrefix + "ApiResources", schema);
+
+                apiResource.Property(x => x.Name).HasMaxLength(ApiResourceConsts.NameMaxLength).IsRequired();
+                apiResource.Property(x => x.DisplayName).HasMaxLength(ApiResourceConsts.DisplayNameMaxLength);
+                apiResource.Property(x => x.Description).HasMaxLength(ApiResourceConsts.DescriptionMaxLength);
+
+                apiResource.HasMany(x => x.Secrets).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
+                apiResource.HasMany(x => x.Scopes).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
+                apiResource.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => x.ApiResourceId).IsRequired();
+            });
+
+            builder.Entity<ApiSecret>(apiSecret =>
+            {
+                apiSecret.ToTable(tablePrefix + "ApiSecrets", schema);
+
+                apiSecret.HasKey(x => new { x.ApiResourceId, x.Type, x.Value });
+
+                apiSecret.Property(x => x.Type).HasMaxLength(SecretConsts.TypeMaxLength).IsRequired();
+                apiSecret.Property(x => x.Value).HasMaxLength(SecretConsts.ValueMaxLength).IsRequired();
+                apiSecret.Property(x => x.Description).HasMaxLength(SecretConsts.DescriptionMaxLength);
+            });
+
+            builder.Entity<ApiResourceClaim>(apiClaim =>
+            {
+                apiClaim.ToTable(tablePrefix + "ApiClaims", schema);
+
+                apiClaim.HasKey(x => new { x.ApiResourceId, x.Type });
+
+                apiClaim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
+            });
+
+            builder.Entity<ApiScope>(apiScope =>
+            {
+                apiScope.ToTable(tablePrefix + "ApiScopes", schema);
+
+                apiScope.HasKey(x => new { x.ApiResourceId, x.Name });
+
+                apiScope.Property(x => x.Name).HasMaxLength(ApiScopeConsts.NameMaxLength).IsRequired();
+                apiScope.Property(x => x.DisplayName).HasMaxLength(ApiScopeConsts.DisplayNameMaxLength);
+                apiScope.Property(x => x.Description).HasMaxLength(ApiScopeConsts.DescriptionMaxLength);
+
+                apiScope.HasMany(x => x.UserClaims).WithOne().HasForeignKey(x => new { x.ApiResourceId, x.Name }).IsRequired();
+            });
+
+            builder.Entity<ApiScopeClaim>(apiScopeClaim =>
+            {
+                apiScopeClaim.ToTable(tablePrefix + "ApiScopeClaims", schema);
+
+                apiScopeClaim.HasKey(x => new { x.ApiResourceId, x.Name, x.Type });
+
+                apiScopeClaim.Property(x => x.Type).HasMaxLength(UserClaimConsts.TypeMaxLength).IsRequired();
+                apiScopeClaim.Property(x => x.Name).HasMaxLength(ApiScopeConsts.NameMaxLength).IsRequired();
+            });
+        }
+    }
+}

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/IdentityResourceRepository.cs

@@ -14,9 +14,9 @@ namespace Volo.Abp.IdentityServer
 {
     //TODO: This is not true implementation! This repository works for 2 different aggregate root!
 
-    public class IdentityResourceRepository : EfCoreRepository<IdentityServerDbContext, IdentityResource, Guid>, IIdentityResourceRepository
+    public class IdentityResourceRepository : EfCoreRepository<IIdentityServerDbContext, IdentityResource, Guid>, IIdentityResourceRepository
     {
-        public IdentityResourceRepository(IDbContextProvider<IdentityServerDbContext> dbContextProvider) 
+        public IdentityResourceRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) 
             : base(dbContextProvider)
         {
 

src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/PersistedGrantRepository.cs

@@ -10,9 +10,9 @@ using Volo.Abp.IdentityServer.Grants;
 
 namespace Volo.Abp.IdentityServer
 {
-    public class PersistentGrantRepository : EfCoreRepository<IdentityServerDbContext, PersistedGrant, Guid>, IPersistentGrantRepository
+    public class PersistentGrantRepository : EfCoreRepository<IIdentityServerDbContext, PersistedGrant, Guid>, IPersistentGrantRepository
     {
-        public PersistentGrantRepository(IDbContextProvider<IdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
+        public PersistentGrantRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) : base(dbContextProvider)
         {
 
         }

src/Volo.Abp.MultiTenancy.EntityFrameworkCore/Volo/Abp/MultiTenancy/EntityFrameworkCore/MultiTenancyDbContext.cs

@@ -18,7 +18,7 @@ namespace Volo.Abp.MultiTenancy.EntityFrameworkCore
         {
             base.OnModelCreating(builder);
 
-            this.ConfigureAbpMultiTenancy(builder);
+            this.ConfigureMultiTenancy(builder);
         }
     }
 }

src/Volo.Abp.MultiTenancy.EntityFrameworkCore/Volo/Abp/MultiTenancy/EntityFrameworkCore/MultiTenancyDbContextModelCreatingExtensions.cs

@@ -4,7 +4,7 @@ namespace Volo.Abp.MultiTenancy.EntityFrameworkCore
 {
     public static class MultiTenancyDbContextModelCreatingExtensions
     {
-        public static void ConfigureAbpMultiTenancy(this IMultiTenancyDbContext dbContext, ModelBuilder builder)
+        public static void ConfigureMultiTenancy(this IMultiTenancyDbContext dbContext, ModelBuilder builder)
         {
             builder.Entity<Tenant>(b =>
             {