feat(relationships): implement relational attrs

jaredcnance · jaredcnance · commit 0b0e8d1577d0 · 2017-03-01T20:46:47.000-06:00
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,6 +1,6 @@
 using System;
-using JsonApiDotNetCore.Models;
 using System.Collections.Generic;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
 {
@@ -9,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
@@ -15,7 +15,6 @@ public class ContextGraphBuilder<T> where T : DbContext
         public ContextGraph<T> Build()
         {
             _getFirstLevelEntities();
-            _loadRelationships();
 
             var graph = new ContextGraph<T>
             {
@@ -42,7 +41,8 @@ private void _getFirstLevelEntities()
                     entities.Add(new ContextEntity {
                         EntityName = property.Name,
                         EntityType = entityType,
-                        Attributes = _getAttributes(entityType)
+                        Attributes = _getAttributes(entityType),
+                        Relationships = _getRelationships(entityType)
                     });
                 }                    
             }
@@ -66,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,9 +17,9 @@ 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)))
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/Relationship.cs b/src/JsonApiDotNetCore/Internal/Relationship.cs
diff --git a/src/JsonApiDotNetCore/Models/HasManyAttribute.cs b/src/JsonApiDotNetCore/Models/HasManyAttribute.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace JsonApiDotNetCore.Models
 {
     public class HasManyAttribute : RelationshipAttribute
diff --git a/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 
 namespace JsonApiDotNetCore.Models
 {
@@ -11,5 +12,17 @@ protected RelationshipAttribute(string 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))
                 {

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,6 +1,6 @@`
`1`	`1`	`using System;`
`2`		`-using JsonApiDotNetCore.Models;`
`3`	`2`	`using System.Collections.Generic;`
	`3`	`+using JsonApiDotNetCore.Models;`
`4`	`4`
`5`	`5`	`namespace JsonApiDotNetCore.Internal`
`6`	`6`	`{`
`@@ -9,6 +9,6 @@ public class ContextEntity`
`9`	`9`	`public string EntityName { get; set; }`
`10`	`10`	`public Type EntityType { get; set; }`
`11`	`11`	`public List<AttrAttribute> Attributes { get; set; }`
`12`		`- public List<Relationship> Relationships { get; set; }`
	`12`	`+ public List<RelationshipAttribute> Relationships { get; set; }`
`13`	`13`	`}`
`14`	`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,9 +17,9 @@ 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`	`24`	`// TODO: replace with relationship.IsMany`
`25`	`25`	`if(relationship.Type.GetInterfaces().Contains(typeof(IEnumerable)))`
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`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+using System;`
	`2`	`+`
`1`	`3`	`namespace JsonApiDotNetCore.Models`
`2`	`4`	`{`
`3`	`5`	`public class HasManyAttribute : RelationshipAttribute`
Original file line number	Diff line number	Diff line change
`@@ -98,12 +98,12 @@ private static object _setRelationships(`
`98`	`98`
`99`	`99`	`foreach (var attr in contextEntity.Relationships)`
`100`	`100`	`{`
`101`		`- var entityProperty = entityProperties.FirstOrDefault(p => p.Name == $"{attr.RelationshipName}Id");`
	`101`	`+ var entityProperty = entityProperties.FirstOrDefault(p => p.Name == $"{attr.InternalRelationshipName}Id");`
`102`	`102`
`103`	`103`	`if (entityProperty == null)`
`104`		`- throw new JsonApiException("400", $"{contextEntity.EntityType.Name} does not contain an relationsip named {attr.RelationshipName}");`
	`104`	`+ throw new JsonApiException("400", $"{contextEntity.EntityType.Name} does not contain an relationsip named {attr.InternalRelationshipName}");`
`105`	`105`
`106`		`- var relationshipName = attr.RelationshipName.Dasherize();`
	`106`	`+ var relationshipName = attr.InternalRelationshipName.Dasherize();`
`107`	`107`	`RelationshipData relationshipData;`
`108`	`108`	`if (relationships.TryGetValue(relationshipName, out relationshipData))`
`109`	`109`	`{`