Merge pull request #44 from Research-Institute/relationship-attributes

jaredcnance · web-flow · commit b247d15863ec · 2017-03-02T06:28:49.000-06:00
Relationship attributes
diff --git a/README.md b/README.md
@@ -113,14 +113,15 @@ public class Person : Identifiable<int>
 #### Relationships
 
 In order for navigation properties to be identified in the model, 
-they should be labeled as virtual.
+they should be labeled with the appropriate attribute (either `HasOne` or `HasMany`).
 
 ```csharp
 public class Person : Identifiable<int>
 {
     [Attr("first-name")]
     public string FirstName { get; set; }
 
+    [HasMany("todo-items")]
     public virtual List<TodoItem> TodoItems { get; set; }
 }
 ```
@@ -135,6 +136,8 @@ public class TodoItem : Identifiable<int>
     public string Description { get; set; }
 
     public int OwnerId { get; set; }
+
+    [HasOne("owner")]
     public virtual Person Owner { get; set; }
 }
 ```
diff --git a/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs b/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs
@@ -124,25 +124,25 @@ private void _addRelationships(DocumentData data, ContextEntity contextEntity, I
                 {
                     Links = new Links
                     {
-                        Self = linkBuilder.GetSelfRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.RelationshipName),
-                        Related = linkBuilder.GetRelatedRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.RelationshipName)
+                        Self = linkBuilder.GetSelfRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.InternalRelationshipName),
+                        Related = linkBuilder.GetRelatedRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.InternalRelationshipName)
                     }
                 };
 
-                if (_relationshipIsIncluded(r.RelationshipName))
+                if (_relationshipIsIncluded(r.InternalRelationshipName))
                 {
                     var navigationEntity = _jsonApiContext.ContextGraph
-                        .GetRelationship(entity, r.RelationshipName);
+                        .GetRelationship(entity, r.InternalRelationshipName);
 
                     if(navigationEntity == null)
                         relationshipData.SingleData = null;
                     else if (navigationEntity is IEnumerable)
-                        relationshipData.ManyData = _getRelationships((IEnumerable<object>)navigationEntity, r.RelationshipName);
+                        relationshipData.ManyData = _getRelationships((IEnumerable<object>)navigationEntity, r.InternalRelationshipName);
                     else
-                        relationshipData.SingleData = _getRelationship(navigationEntity, r.RelationshipName);
+                        relationshipData.SingleData = _getRelationship(navigationEntity, r.InternalRelationshipName);
                 }
 
-                data.Relationships.Add(r.RelationshipName.Dasherize(), relationshipData);
+                data.Relationships.Add(r.InternalRelationshipName.Dasherize(), relationshipData);
             });
         }
 
@@ -152,9 +152,9 @@ private List<DocumentData> _getIncludedEntities(ContextEntity contextEntity, IId
 
             contextEntity.Relationships.ForEach(r =>
             {
-                if (!_relationshipIsIncluded(r.RelationshipName)) return;
+                if (!_relationshipIsIncluded(r.InternalRelationshipName)) return;
 
-                var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.RelationshipName);
+                var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.InternalRelationshipName);
 
                 if (navigationEntity is IEnumerable)
                     foreach (var includedEntity in (IEnumerable)navigationEntity)
diff --git a/src/JsonApiDotNetCore/Controllers/JsonApiController.cs b/src/JsonApiDotNetCore/Controllers/JsonApiController.cs
@@ -183,7 +183,7 @@ public virtual async Task<IActionResult> PatchRelationshipsAsync(TId id, string
             var relationship = _jsonApiContext.ContextGraph
                 .GetContextEntity(typeof(T))
                 .Relationships
-                .FirstOrDefault(r => r.RelationshipName == relationshipName);
+                .FirstOrDefault(r => r.InternalRelationshipName == relationshipName);
 
             var relationshipIds = relationships.Select(r=>r.Id);
             
diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs
@@ -108,9 +108,9 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         return oldEntity;
         }
 
-        public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)
+        public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            var genericProcessor = GenericProcessorFactory.GetProcessor(relationship.BaseType, _context);
+            var genericProcessor = GenericProcessorFactory.GetProcessor(relationship.Type, _context);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 
@@ -131,7 +131,7 @@ public virtual async Task<bool> DeleteAsync(TId id)
         public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
             var entity = _jsonApiContext.RequestEntity;
-            if(entity.Relationships.Any(r => r.RelationshipName == relationshipName))
+            if(entity.Relationships.Any(r => r.InternalRelationshipName == relationshipName))
                 return entities.Include(relationshipName);
             
             throw new JsonApiException("400", "Invalid relationship",
diff --git a/src/JsonApiDotNetCore/Data/IEntityRepository.cs b/src/JsonApiDotNetCore/Data/IEntityRepository.cs
@@ -34,7 +34,7 @@ public interface IEntityRepository<TEntity, in TId>
 
         Task<TEntity> UpdateAsync(TId id, TEntity entity);
 
-        Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);
+        Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
 
         Task<bool> DeleteAsync(TId id);
     }
diff --git a/src/JsonApiDotNetCore/Internal/ContextEntity.cs b/src/JsonApiDotNetCore/Internal/ContextEntity.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
 {
@@ -8,6 +9,6 @@ public class ContextEntity
         public string EntityName { get; set; }
         public Type EntityType { get; set; }
         public List<AttrAttribute> Attributes { get; set; }
-        public List<Relationship> Relationships { get; set; }
+        public List<RelationshipAttribute> Relationships { get; set; }
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/ContextGraph.cs b/src/JsonApiDotNetCore/Internal/ContextGraph.cs
@@ -46,8 +46,8 @@ public string GetRelationshipName<TParent>(string relationshipName)
                     e.EntityType == entityType)
                 .Relationships
                 .FirstOrDefault(r => 
-                    r.RelationshipName.ToLower() == relationshipName.ToLower())
-                ?.RelationshipName;
+                    r.InternalRelationshipName.ToLower() == relationshipName.ToLower())
+                ?.InternalRelationshipName;
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/ContextGraphBuilder.cs b/src/JsonApiDotNetCore/Internal/ContextGraphBuilder.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using Microsoft.EntityFrameworkCore;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
 {
@@ -14,7 +15,6 @@ public class ContextGraphBuilder<T> where T : DbContext
         public ContextGraph<T> Build()
         {
             _getFirstLevelEntities();
-            _loadRelationships();
 
             var graph = new ContextGraph<T>
             {
@@ -41,7 +41,8 @@ private void _getFirstLevelEntities()
                     entities.Add(new ContextEntity {
                         EntityName = property.Name,
                         EntityType = entityType,
-                        Attributes = _getAttributes(entityType)
+                        Attributes = _getAttributes(entityType),
+                        Relationships = _getRelationships(entityType)
                     });
                 }                    
             }
@@ -65,38 +66,29 @@ private List<AttrAttribute> _getAttributes(Type entityType)
             return attributes;
         }
 
-        private void _loadRelationships()
-        {          
-            _entities.ForEach(entity => {
-
-                var relationships = new List<Relationship>();
-                var properties = entity.EntityType.GetProperties();
-                
-                foreach(var entityProperty in properties)
-                {
-                    var propertyType = entityProperty.PropertyType;
-                    
-                    if(_isValidEntity(propertyType) 
-                        || (propertyType.GetTypeInfo().IsGenericType && _isValidEntity(propertyType.GetGenericArguments()[0])))
-                        relationships.Add(_getRelationshipFromPropertyInfo(entityProperty));
-                }
-
-                entity.Relationships = relationships;
-            });
-        }
-
-        private bool _isValidEntity(Type type)
+        private List<RelationshipAttribute> _getRelationships(Type entityType)
         {
-            var validEntityRelationshipTypes = _entities.Select(e => e.EntityType);
-            return validEntityRelationshipTypes.Contains(type);
+            var attributes = new List<RelationshipAttribute>();
+            
+            var properties = entityType.GetProperties();
+
+            foreach(var prop in properties)
+            {
+                var attribute = (RelationshipAttribute)prop.GetCustomAttribute(typeof(RelationshipAttribute));
+                if(attribute == null) continue;
+                attribute.InternalRelationshipName = prop.Name;
+                attribute.Type = _getRelationshipType(attribute, prop);
+                attributes.Add(attribute);
+            }
+            return attributes;
         }
 
-        private Relationship _getRelationshipFromPropertyInfo(PropertyInfo propertyInfo)
+        private Type _getRelationshipType(RelationshipAttribute relation, PropertyInfo prop)
         {
-            return new Relationship {
-                Type = propertyInfo.PropertyType,
-                RelationshipName = propertyInfo.Name
-            };
+            if(relation.IsHasMany)
+                return prop.PropertyType.GetGenericArguments()[0];
+            else
+                return prop.PropertyType;
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs
@@ -17,12 +17,11 @@ public GenericProcessor(DbContext context)
             _context = context;
         }
 
-        public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)
+        public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            var relationshipType = relationship.BaseType;
+            var relationshipType = relationship.Type;
 
-            // TODO: replace with relationship.IsMany
-            if(relationship.Type.GetInterfaces().Contains(typeof(IEnumerable)))
+            if(relationship.IsHasMany)
             {
                 var entities = _context.GetDbSet<T>().Where(x => relationshipIds.Contains(x.Id.ToString())).ToList();
                 relationship.SetValue(parent, entities);
diff --git a/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs
@@ -1,10 +1,11 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
 {
     public interface IGenericProcessor
     {
-        Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);
+        Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/Query/FilterQuery.cs b/src/JsonApiDotNetCore/Internal/Query/FilterQuery.cs
@@ -1,3 +1,5 @@
+using JsonApiDotNetCore.Models;
+
 namespace JsonApiDotNetCore.Internal.Query
 {
     public class FilterQuery
diff --git a/src/JsonApiDotNetCore/Internal/Query/QuerySet.cs b/src/JsonApiDotNetCore/Internal/Query/QuerySet.cs
@@ -4,6 +4,7 @@
 using JsonApiDotNetCore.Extensions;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Http;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
diff --git a/src/JsonApiDotNetCore/Internal/Query/SortQuery.cs b/src/JsonApiDotNetCore/Internal/Query/SortQuery.cs
@@ -1,3 +1,5 @@
+using JsonApiDotNetCore.Models;
+
 namespace JsonApiDotNetCore.Internal.Query
 {
     public class SortQuery
diff --git a/src/JsonApiDotNetCore/Internal/Relationship.cs b/src/JsonApiDotNetCore/Internal/Relationship.cs
diff --git a/src/JsonApiDotNetCore/Models/AttrAttribute.cs b/src/JsonApiDotNetCore/Models/AttrAttribute.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Reflection;
 
-namespace JsonApiDotNetCore.Internal
+namespace JsonApiDotNetCore.Models
 {
     public class AttrAttribute : Attribute
     {
diff --git a/src/JsonApiDotNetCore/Models/HasManyAttribute.cs b/src/JsonApiDotNetCore/Models/HasManyAttribute.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace JsonApiDotNetCore.Models
+{
+    public class HasManyAttribute : RelationshipAttribute
+    {
+        public HasManyAttribute(string publicName)
+        : base(publicName)
+        {
+            PublicRelationshipName = publicName;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Models/HasOneAttribute.cs b/src/JsonApiDotNetCore/Models/HasOneAttribute.cs
@@ -0,0 +1,11 @@
+namespace JsonApiDotNetCore.Models
+{
+    public class HasOneAttribute : RelationshipAttribute
+    {
+        public HasOneAttribute(string publicName)
+        : base(publicName)
+        {
+            PublicRelationshipName = publicName;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Reflection;
+
+namespace JsonApiDotNetCore.Models
+{
+    public class RelationshipAttribute : Attribute
+    {
+        protected RelationshipAttribute(string publicName)
+        {
+            PublicRelationshipName = publicName;
+        }
+
+        public string PublicRelationshipName { get; set; }
+        public string InternalRelationshipName { get; set; }
+        public Type Type { get; set; }
+        public bool IsHasMany { get { return this.GetType() == typeof(HasManyAttribute); } }
+        public bool IsHasOne { get { return this.GetType() == typeof(HasOneAttribute); } }
+
+        public void SetValue(object entity, object newValue)
+        {
+            var propertyInfo = entity
+                .GetType()
+                .GetProperty(InternalRelationshipName);
+            
+            propertyInfo.SetValue(entity, newValue);        
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs b/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs
@@ -98,12 +98,12 @@ private static object _setRelationships(
 
             foreach (var attr in contextEntity.Relationships)
             {
-                var entityProperty = entityProperties.FirstOrDefault(p => p.Name == $"{attr.RelationshipName}Id");
+                var entityProperty = entityProperties.FirstOrDefault(p => p.Name == $"{attr.InternalRelationshipName}Id");
 
                 if (entityProperty == null)
-                    throw new JsonApiException("400", $"{contextEntity.EntityType.Name} does not contain an relationsip named {attr.RelationshipName}");
+                    throw new JsonApiException("400", $"{contextEntity.EntityType.Name} does not contain an relationsip named {attr.InternalRelationshipName}");
 
-                var relationshipName = attr.RelationshipName.Dasherize();
+                var relationshipName = attr.InternalRelationshipName.Dasherize();
                 RelationshipData relationshipData;
                 if (relationships.TryGetValue(relationshipName, out relationshipData))
                 {
diff --git a/src/JsonApiDotNetCore/project.json b/src/JsonApiDotNetCore/project.json
@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-beta1-*",
+  "version": "1.0.0-beta2-*",
 
   "dependencies": {
     "Microsoft.NETCore.App": {
diff --git a/src/JsonApiDotNetCoreExample/Models/Person.cs b/src/JsonApiDotNetCoreExample/Models/Person.cs
@@ -13,7 +13,10 @@ public class Person : Identifiable, IHasMeta
         [Attr("last-name")]
         public string LastName { get; set; }
 
+        [HasMany("todo-items")]
         public virtual List<TodoItem> TodoItems { get; set; }
+        
+        [HasMany("todo-item-collections")]
         public virtual List<TodoItemCollection> TodoItemCollections { get; set; }
 
         public Dictionary<string, object> GetMeta(IJsonApiContext context)
diff --git a/src/JsonApiDotNetCoreExample/Models/TodoItem.cs b/src/JsonApiDotNetCoreExample/Models/TodoItem.cs
diff --git a/src/JsonApiDotNetCoreExample/Models/TodoItemCollection.cs b/src/JsonApiDotNetCoreExample/Models/TodoItemCollection.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DocumentTests/Meta.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DocumentTests/Meta.cs

Original file line number	Diff line number	Diff line change
`@@ -124,25 +124,25 @@ private void _addRelationships(DocumentData data, ContextEntity contextEntity, I`
`124`	`124`	`{`
`125`	`125`	`Links = new Links`
`126`	`126`	`{`
`127`		`- Self = linkBuilder.GetSelfRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.RelationshipName),`
`128`		`- Related = linkBuilder.GetRelatedRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.RelationshipName)`
	`127`	`+ Self = linkBuilder.GetSelfRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.InternalRelationshipName),`
	`128`	`+ Related = linkBuilder.GetRelatedRelationLink(contextEntity.EntityName, entity.Id.ToString(), r.InternalRelationshipName)`
`129`	`129`	`}`
`130`	`130`	`};`
`131`	`131`
`132`		`- if (_relationshipIsIncluded(r.RelationshipName))`
	`132`	`+ if (_relationshipIsIncluded(r.InternalRelationshipName))`
`133`	`133`	`{`
`134`	`134`	`var navigationEntity = _jsonApiContext.ContextGraph`
`135`		`- .GetRelationship(entity, r.RelationshipName);`
	`135`	`+ .GetRelationship(entity, r.InternalRelationshipName);`
`136`	`136`
`137`	`137`	`if(navigationEntity == null)`
`138`	`138`	`relationshipData.SingleData = null;`
`139`	`139`	`else if (navigationEntity is IEnumerable)`
`140`		`- relationshipData.ManyData = _getRelationships((IEnumerable<object>)navigationEntity, r.RelationshipName);`
	`140`	`+ relationshipData.ManyData = _getRelationships((IEnumerable<object>)navigationEntity, r.InternalRelationshipName);`
`141`	`141`	`else`
`142`		`- relationshipData.SingleData = _getRelationship(navigationEntity, r.RelationshipName);`
	`142`	`+ relationshipData.SingleData = _getRelationship(navigationEntity, r.InternalRelationshipName);`
`143`	`143`	`}`
`144`	`144`
`145`		`- data.Relationships.Add(r.RelationshipName.Dasherize(), relationshipData);`
	`145`	`+ data.Relationships.Add(r.InternalRelationshipName.Dasherize(), relationshipData);`
`146`	`146`	`});`
`147`	`147`	`}`
`148`	`148`
`@@ -152,9 +152,9 @@ private List<DocumentData> _getIncludedEntities(ContextEntity contextEntity, IId`
`152`	`152`
`153`	`153`	`contextEntity.Relationships.ForEach(r =>`
`154`	`154`	`{`
`155`		`- if (!_relationshipIsIncluded(r.RelationshipName)) return;`
	`155`	`+ if (!_relationshipIsIncluded(r.InternalRelationshipName)) return;`
`156`	`156`
`157`		`- var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.RelationshipName);`
	`157`	`+ var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.InternalRelationshipName);`
`158`	`158`
`159`	`159`	`if (navigationEntity is IEnumerable)`
`160`	`160`	`foreach (var includedEntity in (IEnumerable)navigationEntity)`
Original file line number	Diff line number	Diff line change
`@@ -108,9 +108,9 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)`
`108`	`108`	`return oldEntity;`
`109`	`109`	`}`
`110`	`110`
`111`		`- public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)`
	`111`	`+ public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)`
`112`	`112`	`{`
`113`		`- var genericProcessor = GenericProcessorFactory.GetProcessor(relationship.BaseType, _context);`
	`113`	`+ var genericProcessor = GenericProcessorFactory.GetProcessor(relationship.Type, _context);`
`114`	`114`	`await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);`
`115`	`115`	`}`
`116`	`116`
`@@ -131,7 +131,7 @@ public virtual async Task<bool> DeleteAsync(TId id)`
`131`	`131`	`public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)`
`132`	`132`	`{`
`133`	`133`	`var entity = _jsonApiContext.RequestEntity;`
`134`		`- if(entity.Relationships.Any(r => r.RelationshipName == relationshipName))`
	`134`	`+ if(entity.Relationships.Any(r => r.InternalRelationshipName == relationshipName))`
`135`	`135`	`return entities.Include(relationshipName);`
`136`	`136`
`137`	`137`	`throw new JsonApiException("400", "Invalid relationship",`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public interface IEntityRepository<TEntity, in TId>`
`34`	`34`
`35`	`35`	`Task<TEntity> UpdateAsync(TId id, TEntity entity);`
`36`	`36`
`37`		`- Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);`
	`37`	`+ Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);`
`38`	`38`
`39`	`39`	`Task<bool> DeleteAsync(TId id);`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using JsonApiDotNetCore.Models;`
`3`	`4`
`4`	`5`	`namespace JsonApiDotNetCore.Internal`
`5`	`6`	`{`
`@@ -8,6 +9,6 @@ public class ContextEntity`
`8`	`9`	`public string EntityName { get; set; }`
`9`	`10`	`public Type EntityType { get; set; }`
`10`	`11`	`public List<AttrAttribute> Attributes { get; set; }`
`11`		`- public List<Relationship> Relationships { get; set; }`
	`12`	`+ public List<RelationshipAttribute> Relationships { get; set; }`
`12`	`13`	`}`
`13`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,8 @@ public string GetRelationshipName<TParent>(string relationshipName)`
`46`	`46`	`e.EntityType == entityType)`
`47`	`47`	`.Relationships`
`48`	`48`	`.FirstOrDefault(r =>`
`49`		`- r.RelationshipName.ToLower() == relationshipName.ToLower())`
`50`		`- ?.RelationshipName;`
	`49`	`+ r.InternalRelationshipName.ToLower() == relationshipName.ToLower())`
	`50`	`+ ?.InternalRelationshipName;`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,11 @@ public GenericProcessor(DbContext context)`
`17`	`17`	`_context = context;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)`
	`20`	`+ public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)`
`21`	`21`	`{`
`22`		`- var relationshipType = relationship.BaseType;`
	`22`	`+ var relationshipType = relationship.Type;`
`23`	`23`
`24`		`- // TODO: replace with relationship.IsMany`
`25`		`- if(relationship.Type.GetInterfaces().Contains(typeof(IEnumerable)))`
	`24`	`+ if(relationship.IsHasMany)`
`26`	`25`	`{`
`27`	`26`	`var entities = _context.GetDbSet<T>().Where(x => relationshipIds.Contains(x.Id.ToString())).ToList();`
`28`	`27`	`relationship.SetValue(parent, entities);`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Threading.Tasks;`
	`3`	`+using JsonApiDotNetCore.Models;`
`3`	`4`
`4`	`5`	`namespace JsonApiDotNetCore.Internal`
`5`	`6`	`{`
`6`	`7`	`public interface IGenericProcessor`
`7`	`8`	`{`
`8`		`- Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);`
	`9`	`+ Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);`
`9`	`10`	`}`
`10`	`11`	`}`