Merge pull request #315 from json-api-dotnet/develop

#312 Deserializer not linking included relationships

Author: jaredcnance

src/JsonApiDotNetCore/Builders/DocumentBuilder.cs

@@ -261,11 +261,14 @@ private ResourceIdentifierObject GetRelationship(object entity)
             var objType = entity.GetType();
             var contextEntity = _jsonApiContext.ContextGraph.GetContextEntity(objType);
 
-            return new ResourceIdentifierObject
-            {
-                Type = contextEntity.EntityName,
-                Id = ((IIdentifiable)entity).StringId
-            };
+            if(entity is IIdentifiable identifiableEntity)
+                return new ResourceIdentifierObject
+                {
+                    Type = contextEntity.EntityName,
+                    Id = identifiableEntity.StringId
+                };
+
+            return null;
         }
 
         private ResourceIdentifierObject GetIndependentRelationshipIdentifier(HasOneAttribute hasOne, IIdentifiable entity)

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -84,13 +84,19 @@ public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshi
 
         public virtual async Task<TEntity> CreateAsync(TEntity entity)
         {
-            AttachHasManyPointers();
+            AttachRelationships();
             _dbSet.Add(entity);
 
             await _context.SaveChangesAsync();
             return entity;
         }
 
+        protected virtual void AttachRelationships()
+        {
+            AttachHasManyPointers();
+            AttachHasOnePointers();
+        }
+
         /// <summary>
         /// This is used to allow creation of HasMany relationships when the
         /// dependent side of the relationship already exists.
@@ -107,6 +113,18 @@ private void AttachHasManyPointers()
             }
         }
 
+        /// <summary>
+        /// This is used to allow creation of HasOne relationships when the
+        /// independent side of the relationship already exists.
+        /// </summary>
+        private void AttachHasOnePointers()
+        {
+            var relationships = _jsonApiContext.HasOneRelationshipPointers.Get();
+            foreach (var relationship in relationships)
+                if (_context.Entry(relationship.Value).State == EntityState.Detached && _context.EntityIsTracked(relationship.Value) == false)
+                    _context.Entry(relationship.Value).State = EntityState.Unchanged;
+        }
+
         public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         {
             var oldEntity = await GetAsync(id);
@@ -185,17 +203,23 @@ public virtual async Task<IEnumerable<TEntity>> PageAsync(IQueryable<TEntity> en
 
         public async Task<int> CountAsync(IQueryable<TEntity> entities)
         {
-            return await entities.CountAsync();
+            return (entities is IAsyncEnumerable<TEntity>)
+                 ? await entities.CountAsync()
+                 : entities.Count();
         }
 
-        public Task<TEntity> FirstOrDefaultAsync(IQueryable<TEntity> entities)
+        public async Task<TEntity> FirstOrDefaultAsync(IQueryable<TEntity> entities)
         {
-            return entities.FirstOrDefaultAsync();
+            return (entities is IAsyncEnumerable<TEntity>)
+               ? await entities.FirstOrDefaultAsync()
+               : entities.FirstOrDefault();
         }
 
         public async Task<IReadOnlyList<TEntity>> ToListAsync(IQueryable<TEntity> entities)
         {
-            return await entities.ToListAsync();
+            return (entities is IAsyncEnumerable<TEntity>)
+                ? await entities.ToListAsync()
+                : entities.ToList();
         }
     }
 }

src/JsonApiDotNetCore/Extensions/DbContextExtensions.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Linq;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
 using Microsoft.EntityFrameworkCore;
 
 namespace JsonApiDotNetCore.Extensions
@@ -8,5 +11,23 @@ public static class DbContextExtensions
         [Obsolete("This is no longer required since the introduction of context.Set<T>", error: false)]
         public static DbSet<T> GetDbSet<T>(this DbContext context) where T : class 
             => context.Set<T>();
+
+        /// <summary>
+        /// Determines whether or not EF is already tracking an entity of the same Type and Id
+        /// </summary>
+        public static bool EntityIsTracked(this DbContext context, IIdentifiable entity)
+        {
+            if (entity == null)
+                throw new ArgumentNullException(nameof(entity));
+            
+            var trackedEntries = context.ChangeTracker
+                .Entries()
+                .FirstOrDefault(entry => 
+                    entry.Entity.GetType() == entity.GetType() 
+                    && ((IIdentifiable)entry.Entity).StringId == entity.StringId
+                );
+
+            return trackedEntries != null;
+        }
     }
 }

src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs

@@ -136,7 +136,6 @@ public static void AddJsonApiInternals(
             services.AddScoped<IJsonApiReader, JsonApiReader>();
             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>();

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -1,4 +1,5 @@
-using System;
+using JsonApiDotNetCore.Internal;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -51,8 +52,20 @@ public static TInterface New<TInterface>(this Type t)
         {
             if (t == null) throw new ArgumentNullException(nameof(t));
 
-            var instance = (TInterface)Activator.CreateInstance(t);
+            var instance = (TInterface)CreateNewInstance(t);
             return instance;
         }
+
+        private static object CreateNewInstance(Type type)
+        {
+            try
+            {
+                return Activator.CreateInstance(type);
+            }
+            catch (Exception e)
+            {
+                throw new JsonApiException(500, $"Type '{type}' cannot be instantiated using the default constructor.", e);
+            }
+        }
     }
 }

src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs

@@ -14,12 +14,7 @@ public interface IGenericProcessor
         void SetRelationships(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
     }
 
-    public class GenericProcessor<T> : GenericProcessor<T, int> where T : class, IIdentifiable<int>
-    {
-        public GenericProcessor(IDbContextResolver contextResolver) : base(contextResolver) { }
-    }
-
-    public class GenericProcessor<T, TId> : IGenericProcessor where T : class, IIdentifiable<TId>
+    public class GenericProcessor<T> : IGenericProcessor where T : class, IIdentifiable
     {
         private readonly DbContext _context;
         public GenericProcessor(IDbContextResolver contextResolver)
@@ -38,12 +33,12 @@ public void SetRelationships(object parent, RelationshipAttribute relationship,
         {
             if (relationship.IsHasMany)
             {
-                var entities = _context.GetDbSet<T>().Where(x => relationshipIds.Contains(x.StringId)).ToList();
+                var entities = _context.Set<T>().Where(x => relationshipIds.Contains(x.StringId)).ToList();
                 relationship.SetValue(parent, entities);
             }
             else
             {
-                var entity = _context.GetDbSet<T>().SingleOrDefault(x => relationshipIds.First() == x.StringId);
+                var entity = _context.Set<T>().SingleOrDefault(x => relationshipIds.First() == x.StringId);
                 relationship.SetValue(parent, entity);
             }
         }

src/JsonApiDotNetCore/JsonApiDotNetCore.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <VersionPrefix>2.3.1</VersionPrefix>
+    <VersionPrefix>2.3.2</VersionPrefix>
     <TargetFrameworks>$(NetStandardVersion)</TargetFrameworks>
     <AssemblyName>JsonApiDotNetCore</AssemblyName>
     <PackageId>JsonApiDotNetCore</PackageId>

src/JsonApiDotNetCore/Models/Identifiable.cs

@@ -15,7 +15,7 @@ public class Identifiable<T> : IIdentifiable<T>
         public string StringId
         {
             get => GetStringId(Id);
-            set => Id = (T)GetConcreteId(value);
+            set => Id = GetTypedId(value);
         }
 
         protected virtual string GetStringId(object value)
@@ -34,6 +34,13 @@ protected virtual string GetStringId(object value)
                 : stringValue;
         }
 
+        protected virtual T GetTypedId(string value)
+        {
+            var convertedValue = TypeHelper.ConvertType(value, typeof(T));
+            return convertedValue == null ? default : (T)convertedValue;
+        }
+
+        [Obsolete("Use GetTypedId instead")]
         protected virtual object GetConcreteId(string value)
         {
             return TypeHelper.ConvertType(value, typeof(T));

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -13,6 +13,17 @@ protected RelationshipAttribute(string publicName, Link documentLinks, bool canI
 
         public string PublicRelationshipName { get; }
         public string InternalRelationshipName { get; internal set; }
+
+        /// <summary>
+        /// The related entity type. This does not necessarily match the navigation property type.
+        /// In the case of a HasMany relationship, this value will be the generic argument type.
+        /// </summary>
+        /// 
+        /// <example>
+        /// <code>
+        /// public List&lt;Articles&gt; Articles { get; set; } // Type => Article
+        /// </code>
+        /// </example>
         public Type Type { get; internal set; }
         public bool IsHasMany => GetType() == typeof(HasManyAttribute);
         public bool IsHasOne => GetType() == typeof(HasOneAttribute);

src/JsonApiDotNetCore/Request/HasOneRelationshipPointers.cs

@@ -0,0 +1,46 @@
+using JsonApiDotNetCore.Models;
+using System;
+using System.Collections.Generic;
+
+namespace JsonApiDotNetCore.Request
+{
+    /// <summary>
+    /// Stores information to set relationships for the request resource. 
+    /// These relationships must already exist and should not be re-created.
+    /// 
+    /// The expected use case is POST-ing or PATCH-ing 
+    /// an entity with HasOne relationships:
+    /// <code>
+    /// {
+    ///    "data": {
+    ///      "type": "photos",
+    ///      "attributes": {
+    ///        "title": "Ember Hamster",
+    ///        "src": "http://example.com/images/productivity.png"
+    ///      },
+    ///      "relationships": {
+    ///        "photographer": {
+    ///          "data": { "type": "people", "id": "2" }
+    ///        }
+    ///      }
+    ///    }
+    ///  }
+    /// </code>
+    /// </summary>
+    public class HasOneRelationshipPointers
+    {
+        private Dictionary<Type, IIdentifiable> _hasOneRelationships = new Dictionary<Type, IIdentifiable>();
+
+        /// <summary>
+        /// Add the relationship to the list of relationships that should be 
+        /// set in the repository layer.
+        /// </summary>
+        public void Add(Type dependentType, IIdentifiable entity)
+            => _hasOneRelationships[dependentType] = entity;
+
+        /// <summary>
+        /// Get all the models that should be associated
+        /// </summary>
+        public Dictionary<Type, IIdentifiable> Get() => _hasOneRelationships;
+    }
+}