fix(CreateOpProcessor): issues around service location

jaredcnance · jaredcnance · commit 2a3cdc45c1da · 2017-11-12T20:36:09.000-06:00
also cleans up some styling
diff --git a/src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs b/src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs
@@ -35,20 +35,22 @@ public IContextGraphBuilder AddResource<TResource, TId>(string pluralizedTypeNam
         {
             var entityType = typeof(TResource);
 
-            VerifyEntityIsNotAlreadyDefined(entityType);
+            AssertEntityIsNotAlreadyDefined(entityType);
 
-            _entities.Add(new ContextEntity
-            {
-                EntityName = pluralizedTypeName,
-                EntityType = entityType,
-                IdentityType = typeof(TId),
-                Attributes = GetAttributes(entityType),
-                Relationships = GetRelationships(entityType)
-            });
+            _entities.Add(GetEntity(pluralizedTypeName, entityType, typeof(TId)));
 
             return this;
         }
 
+        private ContextEntity GetEntity(string pluralizedTypeName, Type entityType, Type idType) => new ContextEntity
+        {
+            EntityName = pluralizedTypeName,
+            EntityType = entityType,
+            IdentityType = idType,
+            Attributes = GetAttributes(entityType),
+            Relationships = GetRelationships(entityType)
+        };
+
         private Link GetLinkFlags(Type entityType)
         {
             var attribute = (LinksAttribute)entityType.GetTypeInfo().GetCustomAttribute(typeof(LinksAttribute));
@@ -116,15 +118,9 @@ public IContextGraphBuilder AddDbContext<T>() where T : DbContext
                 {
                     var entityType = dbSetType.GetGenericArguments()[0];
 
-                    VerifyEntityIsNotAlreadyDefined(entityType);
+                    AssertEntityIsNotAlreadyDefined(entityType);
 
-                    _entities.Add(new ContextEntity
-                    {
-                        EntityName = GetResourceName(property),
-                        EntityType = entityType,
-                        Attributes = GetAttributes(entityType),
-                        Relationships = GetRelationships(entityType)
-                    });
+                    _entities.Add(GetEntity(GetResourceName(property), entityType, GetIdType(entityType)));
                 }
             }
 
@@ -140,7 +136,19 @@ private string GetResourceName(PropertyInfo property)
             return ((ResourceAttribute)resourceAttribute).ResourceName;
         }
 
-        private void VerifyEntityIsNotAlreadyDefined(Type entityType)
+        private Type GetIdType(Type resourceType)
+        {
+            var interfaces = resourceType.GetInterfaces();
+            foreach (var type in interfaces)
+            {
+                if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(IIdentifiable<>))
+                    return type.GetGenericArguments()[0];
+            }
+
+            throw new ArgumentException("Type does not implement 'IIdentifiable<TId>'", nameof(resourceType));
+        }
+
+        private void AssertEntityIsNotAlreadyDefined(Type entityType)
         {
             if (_entities.Any(e => e.EntityType == entityType))
                 throw new InvalidOperationException($"Cannot add entity type {entityType} to context graph, there is already an entity of that type configured.");
diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs
@@ -137,7 +137,7 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
 
         public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(relationship.Type);
+            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), relationship.Type);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 
diff --git a/src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs b/src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs
@@ -10,6 +10,7 @@
 using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Services;
 using JsonApiDotNetCore.Services.Operations;
+using JsonApiDotNetCore.Services.Operations.Processors;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
@@ -99,6 +100,8 @@ public static void AddJsonApiInternals(
             services.AddScoped<IDbContextResolver, DbContextResolver>();
             services.AddScoped(typeof(IEntityRepository<>), typeof(DefaultEntityRepository<>));
             services.AddScoped(typeof(IEntityRepository<,>), typeof(DefaultEntityRepository<,>));
+            services.AddScoped(typeof(ICreateService<>), typeof(EntityResourceService<>));
+            services.AddScoped(typeof(ICreateService<,>), typeof(EntityResourceService<,>));
             services.AddScoped(typeof(IResourceService<>), typeof(EntityResourceService<>));
             services.AddScoped(typeof(IResourceService<,>), typeof(EntityResourceService<,>));
             services.AddSingleton<JsonApiOptions>(jsonApiOptions);
@@ -115,6 +118,7 @@ public static void AddJsonApiInternals(
             services.AddScoped<IJsonApiOperationsReader, JsonApiOperationsReader>();
             services.AddScoped<IGenericProcessorFactory, GenericProcessorFactory>();
             services.AddScoped(typeof(GenericProcessor<>));
+            services.AddScoped(typeof(GenericProcessor<,>));
             services.AddScoped<IQueryAccessor, QueryAccessor>();
             services.AddScoped<IQueryParser, QueryParser>();
             services.AddScoped<IControllerContext, Services.ControllerContext>();
@@ -123,6 +127,8 @@ public static void AddJsonApiInternals(
         private static void AddOperationServices(IServiceCollection services)
         {
             services.AddScoped<IOperationsProcessor, OperationsProcessor>();
+            services.AddScoped(typeof(ICreateOpProcessor<>), typeof(CreateOpProcessor<>));
+            services.AddScoped(typeof(ICreateOpProcessor<,>), typeof(CreateOpProcessor<,>));
             services.AddSingleton<IOperationProcessorResolver, OperationProcessorResolver>();
             services.AddSingleton<IGenericProcessorFactory, GenericProcessorFactory>();
         }
diff --git a/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs
@@ -7,7 +7,18 @@
 
 namespace JsonApiDotNetCore.Internal.Generics
 {
-    public class GenericProcessor<T> : IGenericProcessor where T : class, IIdentifiable
+    public interface IGenericProcessor
+    {
+        Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
+        void SetRelationships(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
+    }
+
+    public class GenericProcessor<T> : GenericProcessor<T, int> where T : class, IIdentifiable<int>
+    {
+        public GenericProcessor(DbContext context) : base(context) { }
+    }
+
+    public class GenericProcessor<T, TId> : IGenericProcessor where T : class, IIdentifiable<TId>
     {
         private readonly DbContext _context;
         public GenericProcessor(DbContext context)
diff --git a/src/JsonApiDotNetCore/Internal/Generics/GenericProcessorFactory.cs b/src/JsonApiDotNetCore/Internal/Generics/GenericProcessorFactory.cs
@@ -2,6 +2,30 @@
 
 namespace JsonApiDotNetCore.Internal.Generics
 {
+    /// <summary>
+    /// Used to generate a generic operations processor when the types
+    /// are not known until runtime. The typical use case would be for
+    /// accessing relationship data or resolving operations processors.
+    /// </summary>
+    public interface IGenericProcessorFactory
+    {
+        /// <summary>
+        /// Constructs the generic type and locates the service, then casts to TInterface
+        /// </summary>
+        /// <example>
+        ///     GetProcessor&lt;IGenericProcessor&gt;(typeof(GenericProcessor&lt;&gt;), typeof(TResource));
+        /// </example>
+        TInterface GetProcessor<TInterface>(Type openGenericType, Type resourceType);
+
+        /// <summary>
+        /// Constructs the generic type and locates the service, then casts to TInterface
+        /// </summary>
+        /// <example>
+        ///     GetProcessor&lt;IGenericProcessor&gt;(typeof(GenericProcessor&lt;,&gt;), typeof(TResource), typeof(TId));
+        /// </example>
+        TInterface GetProcessor<TInterface>(Type openGenericType, Type resourceType, Type keyType);
+    }
+
     public class GenericProcessorFactory : IGenericProcessorFactory
     {
         private readonly IServiceProvider _serviceProvider;
@@ -11,10 +35,17 @@ public GenericProcessorFactory(IServiceProvider serviceProvider)
             _serviceProvider = serviceProvider;
         }
 
-        public TInterface GetProcessor<TInterface>(Type[] types)
+        public TInterface GetProcessor<TInterface>(Type openGenericType, Type resourceType)
+            => _getProcessor<TInterface>(openGenericType, resourceType);
+
+        public TInterface GetProcessor<TInterface>(Type openGenericType, Type resourceType, Type keyType)
+            => _getProcessor<TInterface>(openGenericType, resourceType, keyType);
+
+        private TInterface _getProcessor<TInterface>(Type openGenericType, params Type[] types)
         {
-            var processorType = typeof(GenericProcessor<>).MakeGenericType(types);
-            return (TInterface)_serviceProvider.GetService(processorType);
+            var concreteType = openGenericType.MakeGenericType(types);
+
+            return (TInterface)_serviceProvider.GetService(concreteType);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs
diff --git a/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessorFactory.cs b/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessorFactory.cs
diff --git a/src/JsonApiDotNetCore/Models/DocumentBase.cs b/src/JsonApiDotNetCore/Models/DocumentBase.cs
@@ -5,29 +5,13 @@ namespace JsonApiDotNetCore.Models
 {
     public class DocumentBase
     {
-        [JsonProperty("links")]
+        [JsonProperty("links", NullValueHandling = NullValueHandling.Ignore)]
         public RootLinks Links { get; set; }
 
-        [JsonProperty("included")]
+        [JsonProperty("included", NullValueHandling = NullValueHandling.Ignore)]
         public List<DocumentData> Included { get; set; }
 
-        [JsonProperty("meta")]
+        [JsonProperty("meta", NullValueHandling = NullValueHandling.Ignore)]
         public Dictionary<string, object> Meta { get; set; }
-
-        // http://www.newtonsoft.com/json/help/html/ConditionalProperties.htm
-        public bool ShouldSerializeIncluded()
-        {
-            return (Included != null);
-        }
-
-        public bool ShouldSerializeMeta()
-        {
-            return (Meta != null);
-        }
-
-        public bool ShouldSerializeLinks()
-        {
-            return (Links != null);
-        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Models/DocumentData.cs b/src/JsonApiDotNetCore/Models/DocumentData.cs
@@ -14,7 +14,7 @@ public class DocumentData
         [JsonProperty("attributes")]
         public Dictionary<string, object> Attributes { get; set; }
 
-        [JsonProperty("relationships")]
+        [JsonProperty("relationships", NullValueHandling = NullValueHandling.Ignore)]
         public Dictionary<string, RelationshipData> Relationships { get; set; }
     }
 }
diff --git a/src/JsonApiDotNetCore/Models/Operations/Operation.cs b/src/JsonApiDotNetCore/Models/Operations/Operation.cs
@@ -1,18 +1,19 @@
 using System.Collections.Generic;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
 
 namespace JsonApiDotNetCore.Models.Operations
 {
     public class Operation : DocumentBase
     {
-        [JsonProperty("op")]
+        [JsonProperty("op"), JsonConverter(typeof(StringEnumConverter))]
         public OperationCode Op { get; set; }
 
-        [JsonProperty("ref")]
+        [JsonProperty("ref", NullValueHandling = NullValueHandling.Ignore)]
         public ResourceReference Ref { get; set; }
 
-        [JsonProperty("params")]
+        [JsonProperty("params", NullValueHandling = NullValueHandling.Ignore)]
         public Params Params { get; set; }
 
         [JsonProperty("data")]
@@ -28,32 +29,41 @@ public object Data
 
         private void SetData(object data)
         {
-            if (data is JArray jArray) {
+            if (data is JArray jArray)
+            {
                 DataIsList = true;
                 DataList = jArray.ToObject<List<DocumentData>>();
             }
-            else if (data is List<DocumentData> dataList) {
+            else if (data is List<DocumentData> dataList)
+            {
                 DataIsList = true;
                 DataList = dataList;
             }
-            else if (data is JObject jObject) {
+            else if (data is JObject jObject)
+            {
                 DataObject = jObject.ToObject<DocumentData>();
             }
-            else if (data is DocumentData dataObject) {
+            else if (data is DocumentData dataObject)
+            {
                 DataObject = dataObject;
             }
         }
 
+        [JsonIgnore]
         public bool DataIsList { get; private set; }
+
+        [JsonIgnore]
         public List<DocumentData> DataList { get; private set; }
+
+        [JsonIgnore]
         public DocumentData DataObject { get; private set; }
 
         public string GetResourceTypeName()
         {
-            if(Ref != null)
+            if (Ref != null)
                 return Ref.Type?.ToString();
 
-            if(DataIsList)
+            if (DataIsList)
                 return DataList[0].Type?.ToString();
 
             return DataObject.Type?.ToString();
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs b/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs
@@ -210,7 +210,7 @@ private object SetHasManyRelationship(object entity,
 
                 if (data == null) return entity;
 
-                var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(attr.Type);
+                var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), attr.Type);
                 var ids = relationshipData.ManyData.Select(r => r["id"].ToString());
                 genericProcessor.SetRelationships(entity, attr, ids);
             }
diff --git a/src/JsonApiDotNetCore/Services/Operations/IOpProcessor.cs b/src/JsonApiDotNetCore/Services/Operations/IOpProcessor.cs
@@ -1,5 +1,4 @@
 using System.Threading.Tasks;
-using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.Operations;
 
 namespace JsonApiDotNetCore.Services.Operations
@@ -8,8 +7,4 @@ public interface IOpProcessor
     {
         Task<Operation> ProcessAsync(Operation operation);
     }
-
-    public interface IOpProcessor<T, TId> : IOpProcessor 
-        where T : class, IIdentifiable<TId>
-    { }
 }
diff --git a/src/JsonApiDotNetCore/Services/Operations/OperationProcessorResolver.cs b/src/JsonApiDotNetCore/Services/Operations/OperationProcessorResolver.cs
@@ -1,6 +1,7 @@
 using System.Collections.Concurrent;
 using JsonApiDotNetCore.Internal.Generics;
 using JsonApiDotNetCore.Models.Operations;
+using JsonApiDotNetCore.Services.Operations.Processors;
 
 namespace JsonApiDotNetCore.Services.Operations
 {
@@ -33,10 +34,12 @@ public IOpProcessor LocateCreateService(Operation operation)
                 return cachedProcessor;
 
             var contextEntity = _context.ContextGraph.GetContextEntity(resource);
-            var processor = _processorFactory.GetProcessor<IOpProcessor>(contextEntity.EntityType, contextEntity.IdentityType);
-            
+            var processor = _processorFactory.GetProcessor<IOpProcessor>(
+                typeof(ICreateOpProcessor<,>), contextEntity.EntityType, contextEntity.IdentityType
+            );
+
             _cachedProcessors[resource] = processor;
-            
+
             return processor;
         }
     }
diff --git a/src/JsonApiDotNetCore/Services/Operations/OperationsProcessor.cs b/src/JsonApiDotNetCore/Services/Operations/OperationsProcessor.cs
diff --git a/src/JsonApiDotNetCore/Services/Operations/Processors/CreateOpProcessor.cs b/src/JsonApiDotNetCore/Services/Operations/Processors/CreateOpProcessor.cs

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)`
`137`	`137`
`138`	`138`	`public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)`
`139`	`139`	`{`
`140`		`- var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(relationship.Type);`
	`140`	`+ var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), relationship.Type);`
`141`	`141`	`await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);`
`142`	`142`	`}`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class DocumentData`
`14`	`14`	`[JsonProperty("attributes")]`
`15`	`15`	`public Dictionary<string, object> Attributes { get; set; }`
`16`	`16`
`17`		`- [JsonProperty("relationships")]`
	`17`	`+ [JsonProperty("relationships", NullValueHandling = NullValueHandling.Ignore)]`
`18`	`18`	`public Dictionary<string, RelationshipData> Relationships { get; set; }`
`19`	`19`	`}`
`20`	`20`	`}`