generic reflector

Author: jaredcnance

Diff for: src/JsonApiDotNetCore/Reflection/GenericReflector.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace JsonApiDotNetCore.Reflection
+{
+    public static class GenericReflector
+    {
+        /// <summary>
+        /// Gets an inherited generic argument.
+        /// </summary>
+        /// 
+        /// <example>
+        /// Consider `ArticlesController : JsonApiController{Article}`:
+        /// 
+        /// var result = GenericReflector.GetInheritedGenericType(typeof(ArticlesController), typeof(JsonApiController<>))
+        /// 
+        /// // result will be the `Article` type.
+        /// </example>
+        public static Type GetInheritedGenericType(Type derivedType, Type openGenericBaseType, int genericArgumentIndex = 0)
+        {
+            var baseType = derivedType.BaseType;
+            while (baseType != null)
+            {
+                if (baseType.IsGenericType)
+                {
+                    var genericTypeDefinition = baseType.GetGenericTypeDefinition();
+                    if (openGenericBaseType.IsAssignableFrom(genericTypeDefinition))
+                    {
+                        var genericArguments = baseType.GetGenericArguments();
+                        if (genericArguments.Length > genericArgumentIndex)
+                            return genericArguments[genericArgumentIndex];
+                    }
+                }
+
+                // it's possible that we have several levels of inheritence
+                // e.g. ArticleController1 : ArticleController2 : JsonApiController<Article>
+                baseType = baseType.BaseType;
+            }
+
+            return null;
+        }
+    }
+}

Diff for: src/JsonApiDotNetCore/Services/ControllerContextActionFilter.cs

@@ -0,0 +1,71 @@
+using JsonApiDotNetCore.Internal;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Services
+{
+    public class ControllerContextActionFilter : IActionFilter
+    {
+        private readonly IControllerContext _controllerContext;
+        private readonly IContextGraph _contextGraph;
+        private readonly ILogger<ControllerContextActionFilter> _logger;
+
+        public ControllerContextActionFilter(
+            IControllerContext controllerContext,
+            IContextGraph contextGraph,
+            ILogger<ControllerContextActionFilter> logger)
+        {
+            _controllerContext = controllerContext;
+            _contextGraph = contextGraph;
+            _logger = logger;
+        }
+
+        public void OnActionExecuted(ActionExecutedContext context)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void OnActionExecuting(ActionExecutingContext context)
+        {
+            // var controller = context.Controller;
+
+            // if (controller == null)
+            //     throw new JsonApiException(500, $"Cannot ApplyContext from null controller for type {typeof(T)}");
+
+            // if (controller == null)
+            //     throw new JsonApiException(500, $"Cannot ApplyContext from null controller for type {typeof(T)}");
+
+            // _controllerContext.ControllerType = controller.GetType();
+            // _controllerContext.RequestEntity = _contextGraph.GetContextEntity(typeof(T));
+
+            // if (_controllerContext.RequestEntity == null)
+            //     throw new JsonApiException(500, $"A resource has not been properly defined for type '{typeof(T)}'. Ensure it has been registered on the ContextGraph.");
+        }
+
+        // private Type GetResourceType(Type controllerType)
+        // {
+        //     var interfaces = controllerType.GetInterfaces();
+        //     var jsonApiControllerOpenGeneric = typeof(BaseJsonApiController<,>);
+        //     foreach (var @interface in interfaces)
+        //     {
+
+        //         if (@interface.IsGenericType && jsonApiControllerOpenGeneric.IsAssignableFrom(@interface))
+        //         {
+
+        //         }
+        //     }
+        // }
+
+        // private ContextEntity GetRequestEntity(Type controllerType)
+        // {
+        //     var controllerGenericArguments = controllerType.GetGenericArguments();
+        //     if (controllerGenericArguments.Length == 0)
+        //     {
+        //         // TODO: are there any use-cases that this will fail on?
+        //         // e.g. ArticlesController : 
+        //         _logger.LogDebug($"Cannot determine the requested resource. Controller {controllerType} does not have any generic parameters.");
+        //         return null;
+        //     }
+        // }
+    }
+}

Diff for: src/JsonApiDotNetCore/Services/IJsonApiContext.cs

@@ -25,7 +25,16 @@ public interface IQueryRequest
 
     public interface IUpdateRequest
     {
+        /// <summary>
+        /// The attributes that were included in a PATCH request. 
+        /// Only the attributes in this dictionary should be updated.
+        /// </summary>
         Dictionary<AttrAttribute, object> AttributesToUpdate { get; set; }
+
+        /// <summary>
+        /// Any relationships that were included in a PATCH request. 
+        /// Only the relationships in this dictionary should be updated.
+        /// </summary>
         Dictionary<RelationshipAttribute, object> RelationshipsToUpdate { get; set; }
     }
 

Diff for: src/JsonApiDotNetCore/Services/ResourceControllersMap.cs

@@ -0,0 +1,7 @@
+namespace JsonApiDotNetCore.Services
+{
+    public class ResourceControllersMap
+    {
+        
+    }
+}

Diff for: test/UnitTests/Reflection/GenericReflector_Tests.cs

@@ -0,0 +1,42 @@
+using System;
+using JsonApiDotNetCore.Controllers;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Reflection;
+using JsonApiDotNetCore.Services;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace UnitTests.Reflection
+{
+    public class GenericReflector_Tests
+    {
+        [Theory]
+        [InlineData(typeof(Controller), typeof(JsonApiController<>), typeof(Resource))]
+        [InlineData(typeof(Controller), typeof(JsonApiController<,>), typeof(Resource))]
+        // [InlineData(typeof(Controller), typeof(BaseJsonApiController<>), typeof(Resource))]
+        [InlineData(typeof(Controller), typeof(BaseJsonApiController<,>), typeof(Resource))]
+        public void GetInheritedGenericType_Gets_ResourceType_From_Controller(Type controllerType, Type openGenericType, Type expectedResult)
+        {
+            // act
+            var result = GenericReflector.GetInheritedGenericType(controllerType, openGenericType);
+
+            // assert
+            Assert.Equal(expectedResult, result);
+        }
+
+        public class Controller2 : Controller
+        {
+            public Controller2(IJsonApiContext jsonApiContext, IResourceService<Resource> resourceService, ILoggerFactory loggerFactory)
+                : base(jsonApiContext, resourceService, loggerFactory) { }
+        }
+
+
+        public class Controller : JsonApiController<Resource>
+        {
+            public Controller(IJsonApiContext jsonApiContext, IResourceService<Resource> resourceService, ILoggerFactory loggerFactory)
+                : base(jsonApiContext, resourceService, loggerFactory) { }
+        }
+
+        public class Resource : Identifiable { }
+    }
+}