include relationships when materializing

Chris Santero · Chris Santero · commit f13058b69c57 · 2015-06-29T23:29:05.000-04:00
diff --git a/JSONAPI.EntityFramework/EntityFrameworkResourceObjectMaterializer.cs b/JSONAPI.EntityFramework/EntityFrameworkResourceObjectMaterializer.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Data.Entity;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,6 +21,7 @@ public class EntityFrameworkResourceObjectMaterializer : IEntityFrameworkResourc
         private readonly DbContext _dbContext;
         private readonly IResourceTypeRegistry _registry;
         private readonly MethodInfo _openSetToManyRelationshipValueMethod;
+        private readonly MethodInfo _openGetExistingRecordGenericMethod;
 
         /// <summary>
         /// Creates a new EntityFrameworkEntityFrameworkResourceObjectMaterializer
@@ -32,13 +34,25 @@ public EntityFrameworkResourceObjectMaterializer(DbContext dbContext, IResourceT
             _registry = registry;
             _openSetToManyRelationshipValueMethod = GetType()
                 .GetMethod("SetToManyRelationshipValue", BindingFlags.NonPublic | BindingFlags.Instance);
+            _openGetExistingRecordGenericMethod = GetType()
+                .GetMethod("GetExistingRecordGeneric", BindingFlags.NonPublic | BindingFlags.Instance);
         }
 
         public async Task<object> MaterializeResourceObject(IResourceObject resourceObject, CancellationToken cancellationToken)
         {
             var registration = _registry.GetRegistrationForResourceTypeName(resourceObject.Type);
+            
+            var relationshipsToInclude = new List<ResourceTypeRelationship>();
+            if (resourceObject.Relationships != null)
+            {
+                relationshipsToInclude.AddRange(
+                    resourceObject.Relationships
+                        .Select(relationshipObject => registration.GetFieldByName(relationshipObject.Key))
+                        .OfType<ResourceTypeRelationship>());
+            }
 
-            var material = await GetExistingRecord(registration, resourceObject.Id, cancellationToken);
+
+            var material = await GetExistingRecord(registration, resourceObject.Id, relationshipsToInclude.ToArray(), cancellationToken);
             if (material == null)
             {
                 material = Activator.CreateInstance(registration.Type);
@@ -64,13 +78,13 @@ protected virtual Task SetIdForNewResource(IResourceObject resourceObject, objec
         /// <summary>
         /// Gets an existing record from the store by ID, if it exists
         /// </summary>
-        /// <param name="registration"></param>
-        /// <param name="id"></param>
-        /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        protected virtual Task<object> GetExistingRecord(IResourceTypeRegistration registration, string id, CancellationToken cancellationToken)
+        protected virtual async Task<object> GetExistingRecord(IResourceTypeRegistration registration, string id,
+            ResourceTypeRelationship[] relationshipsToInclude, CancellationToken cancellationToken)
         {
-            return _dbContext.Set(registration.Type).FindAsync(cancellationToken, id);
+            var method = _openGetExistingRecordGenericMethod.MakeGenericMethod(registration.Type);
+            var result = (dynamic) method.Invoke(this, new object[] {registration, id, relationshipsToInclude, cancellationToken});
+            return await result;
         }
 
         /// <summary>
@@ -127,7 +141,7 @@ protected virtual async Task MergeFieldsIntoProperties(IResourceObject resourceO
                         var relatedId = resourceIdentifierObject["id"].Value<string>();
                         
                         var relatedObjectRegistration = _registry.GetRegistrationForResourceTypeName(relatedType);
-                        var relatedObject = await GetExistingRecord(relatedObjectRegistration, relatedId, cancellationToken);
+                        var relatedObject = await GetExistingRecord(relatedObjectRegistration, relatedId, null, cancellationToken);
                         newCollection.Add(relatedObject);
                     }
 
@@ -142,9 +156,6 @@ protected virtual async Task MergeFieldsIntoProperties(IResourceObject resourceO
 
                     if (linkage.LinkageToken == null)
                     {
-                        // For some reason we have to get the value first, or else setting it to null does nothing.
-                        // TODO: This will cause a synchronous query. We can get rid of this line entirely by using Include when the object is first fetched.
-                        typeRelationship.Property.GetValue(material);
                         typeRelationship.Property.SetValue(material, null);
                     }
                     else
@@ -161,20 +172,40 @@ protected virtual async Task MergeFieldsIntoProperties(IResourceObject resourceO
 
                         var relatedObjectRegistration = _registry.GetRegistrationForResourceTypeName(relatedType);
                         var relatedObject =
-                            await GetExistingRecord(relatedObjectRegistration, relatedId, cancellationToken);
+                            await GetExistingRecord(relatedObjectRegistration, relatedId, null, cancellationToken);
 
                         typeRelationship.Property.SetValue(material, relatedObject);
                     }
                 }
             }
         }
 
+        /// <summary>
+        /// Gets a record by ID
+        /// </summary>
+        protected async Task<TRecord> GetExistingRecordGeneric<TRecord>(IResourceTypeRegistration registration,
+            string id, ResourceTypeRelationship[] relationshipsToInclude, CancellationToken cancellationToken) where TRecord : class
+        {
+            var param = Expression.Parameter(registration.Type);
+            var filterExpression = registration.GetFilterByIdExpression(param, id);
+            var lambda = Expression.Lambda<Func<TRecord, bool>>(filterExpression, param);
+            var query = _dbContext.Set<TRecord>().AsQueryable()
+                .Where(lambda);
+
+            if (relationshipsToInclude != null)
+            {
+                query = relationshipsToInclude.Aggregate(query,
+                    (current, resourceTypeRelationship) => current.Include(resourceTypeRelationship.Property.Name));
+            }
+
+            return await query.FirstOrDefaultAsync(cancellationToken);
+        }
+
         /// <summary>
         /// Sets the value of a to-many relationship
         /// </summary>
         protected void SetToManyRelationshipValue<TRelated>(object material, IEnumerable<object> relatedObjects, ResourceTypeRelationship relationship)
         {
-            // TODO: we need to fetch this property asynchronously first
             var currentValue = relationship.Property.GetValue(material);
             var typedArray = relatedObjects.Select(o => (TRelated) o).ToArray();
             if (relationship.Property.PropertyType.IsAssignableFrom(typeof (List<TRelated>)))
