Fix registering customized identity dbcontext, user and role.

Author: mo-esmp

src/DynamicAuthorization.Mvc.Core/Extensions/ServiceCollectionExtensions.cs

@@ -1,30 +1,71 @@
 using DynamicAuthorization.Mvc.Core.Builder;
 using DynamicAuthorization.Mvc.Core.Models;
-using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using System;
 
 namespace DynamicAuthorization.Mvc.Core.Extensions
 {
     public static class ServiceCollectionExtensions
     {
-        public static IDynamicAuthorizationBuilder AddDynamicAuthorization<TDbContext>(this IServiceCollection services, Action<DynamicAuthorizationOptions> options)
-            where TDbContext : IdentityDbContext
+        public static IDynamicAuthorizationBuilder AddDynamicAuthorization<TDbContext>(this IServiceCollection services,
+            Action<DynamicAuthorizationOptions> options)
+            where TDbContext : DbContext
         {
             var dynamicAuthorizationOptions = new DynamicAuthorizationOptions();
             options.Invoke(dynamicAuthorizationOptions);
             services.AddSingleton(dynamicAuthorizationOptions);
 
-            services.AddSingleton<IMvcControllerDiscovery, MvcControllerDiscovery>();
+            var baseType = typeof(TDbContext).BaseType;
+            var paramsLength = baseType.GetGenericArguments().Length;
+            Type userType;
 
-            services.Configure<MvcOptions>(mvcOptions =>
+            switch (paramsLength)
             {
-                mvcOptions.Filters.Add(typeof(DynamicAuthorizationFilter<TDbContext>));
-            });
+                case 1:
+                    userType = baseType.GetGenericArguments()[0];
+                    DynamicAuthorizationOptions.UserType = userType;
+                    DynamicAuthorizationOptions.RoleType = typeof(IdentityRole);
+                    DynamicAuthorizationOptions.KeyType = typeof(string);
+                    services.Configure<MvcOptions>(mvcOptions =>
+                    {
+                        mvcOptions.Filters.Add(typeof(DynamicAuthorizationFilter<,>).MakeGenericType(typeof(TDbContext), userType));
+                    });
+                    break;
+
+                case 3:
+                    userType = baseType.GetGenericArguments()[0];
+                    var roleType = baseType.GetGenericArguments()[1];
+                    var keyType = baseType.GetGenericArguments()[2];
+                    DynamicAuthorizationOptions.UserType = userType;
+                    DynamicAuthorizationOptions.RoleType = roleType;
+                    DynamicAuthorizationOptions.KeyType = keyType;
+                    services.Configure<MvcOptions>(mvcOptions =>
+                    {
+                        mvcOptions.Filters.Add(typeof(DynamicAuthorizationFilter<,,,>)
+                            .MakeGenericType(typeof(TDbContext), userType, roleType, keyType));
+                    });
+                    break;
+
+                default:
+                    DynamicAuthorizationOptions.UserType = typeof(IdentityUser);
+                    DynamicAuthorizationOptions.RoleType = typeof(IdentityRole);
+                    DynamicAuthorizationOptions.KeyType = typeof(string);
+                    services.Configure<MvcOptions>(mvcOptions =>
+                    {
+                        mvcOptions.Filters.Add(typeof(DynamicAuthorizationFilter<>).MakeGenericType(typeof(TDbContext)));
+                    });
+                    break;
+            }
+
+            services.AddSingleton<IMvcControllerDiscovery, MvcControllerDiscovery>();
 
             IDynamicAuthorizationBuilder builder = new DynamicAuthorizationBuilder(services);
 
+            DynamicAuthorizationOptions.DbContextType = typeof(TDbContext);
+
             return builder;
         }
     }

src/DynamicAuthorization.Mvc.Core/Filters/DynamicAuthorizationFilter.cs

@@ -1,5 +1,6 @@
 using DynamicAuthorization.Mvc.Core.Models;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Authorization;
@@ -13,27 +14,51 @@
 
 namespace DynamicAuthorization.Mvc.Core
 {
-    public class DynamicAuthorizationFilter<TDbContext> : IAuthorizationFilter, IAsyncAuthorizationFilter
+    public class DynamicAuthorizationFilter<TDbContext> : DynamicAuthorizationFilter<TDbContext, IdentityUser, IdentityRole, string>
         where TDbContext : IdentityDbContext
+    {
+        public DynamicAuthorizationFilter(
+            DynamicAuthorizationOptions authorizationOptions,
+            TDbContext dbContext,
+            IRoleAccessStore roleAccessStore
+        ) : base(authorizationOptions, dbContext, roleAccessStore)
+        {
+        }
+    }
+
+    public class DynamicAuthorizationFilter<TDbContext, TUser> : DynamicAuthorizationFilter<TDbContext, TUser, IdentityRole, string>
+        where TDbContext : IdentityDbContext<TUser>
+        where TUser : IdentityUser
+    {
+        public DynamicAuthorizationFilter(
+            DynamicAuthorizationOptions authorizationOptions,
+            TDbContext dbContext,
+            IRoleAccessStore roleAccessStore
+        ) : base(authorizationOptions, dbContext, roleAccessStore)
+        {
+        }
+    }
+
+    public class DynamicAuthorizationFilter<TDbContext, TUser, TRole, TKey> : IAsyncAuthorizationFilter
+        where TDbContext : IdentityDbContext<TUser, TRole, TKey>
+        where TUser : IdentityUser<TKey>
+        where TRole : IdentityRole<TKey>
+        where TKey : IEquatable<TKey>
+
     {
         private readonly DynamicAuthorizationOptions _authorizationOptions;
-        private readonly TDbContext _identityDbContext;
+        private readonly TDbContext _dbContext;
         private readonly IRoleAccessStore _roleAccessStore;
 
         public DynamicAuthorizationFilter(
             DynamicAuthorizationOptions authorizationOptions,
-            TDbContext identityDbContext,
+            TDbContext dbContext,
             IRoleAccessStore roleAccessStore
         )
         {
             _authorizationOptions = authorizationOptions;
             _roleAccessStore = roleAccessStore;
-            _identityDbContext = identityDbContext;
-        }
-
-        public void OnAuthorization(AuthorizationFilterContext context)
-        {
-            OnAuthorizationAsync(context).RunSynchronously();
+            _dbContext = dbContext;
         }
 
         public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
@@ -52,12 +77,13 @@ public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
                 return;
 
             var actionId = GetActionId(context);
+
             var roles = await (
-                from user in _identityDbContext.Users
-                join userRole in _identityDbContext.UserRoles on user.Id equals userRole.UserId
-                join role in _identityDbContext.Roles on userRole.RoleId equals role.Id
+                from user in _dbContext.Users
+                join userRole in _dbContext.UserRoles on user.Id equals userRole.UserId
+                join role in _dbContext.Roles on userRole.RoleId equals role.Id
                 where user.UserName == userName
-                select role.Id
+                select role.Id.ToString()
             ).ToArrayAsync();
 
             if (await _roleAccessStore.HasAccessToActionAsync(actionId, roles))
@@ -71,7 +97,7 @@ select role.Id
         private static bool IsProtectedAction(AuthorizationFilterContext context)
         {
             var controllerActionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
-            if(controllerActionDescriptor == null)
+            if (controllerActionDescriptor == null)
                 return false;
 
             var controllerTypeInfo = controllerActionDescriptor.ControllerTypeInfo;

src/DynamicAuthorization.Mvc.Core/Models/DynamicAuthorizationOptions.cs

@@ -1,7 +1,20 @@
-namespace DynamicAuthorization.Mvc.Core.Models
+using System;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("DynamicAuthorization.Mvc.Ui")]
+
+namespace DynamicAuthorization.Mvc.Core.Models
 {
     public class DynamicAuthorizationOptions
     {
         public string DefaultAdminUser { get; set; }
+
+        internal static Type DbContextType { get; set; }
+
+        internal static Type UserType { get; set; }
+
+        internal static Type RoleType { get; set; }
+
+        internal static Type KeyType { get; set; }
     }
 }