Merge pull request #518 from json-api-dotnet/fix/reattachment

DefaultEntityRepository cleanup

Author: maurei

src/Examples/JsonApiDotNetCoreExample/Models/Passport.cs

@@ -0,0 +1,11 @@
+using JsonApiDotNetCore.Models;
+
+namespace JsonApiDotNetCoreExample.Models
+{
+    public class Passport : Identifiable
+    {
+        public virtual int? SocialSecurityNumber { get; set; }
+        [HasOne("person")]
+        public virtual Person Person { get; set; }
+    }
+}

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -45,5 +45,9 @@ public Dictionary<string, object> GetMeta(IJsonApiContext context)
                 { "authors", new string[] { "Jared Nance" } }
             };
         }
+        public int? PassportId { get; set; }
+        [HasOne("passport")]
+        public virtual Passport Passport { get; set; }
+
     }
 }

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Models;
@@ -14,6 +15,9 @@ public interface IEntityWriteRepository<TEntity, in TId>
     {
         Task<TEntity> CreateAsync(TEntity entity);
 
+        Task<TEntity> UpdateAsync(TEntity entity);
+
+        [Obsolete("Use overload UpdateAsync(TEntity updatedEntity): providing parameter ID does no longer add anything relevant")]
         Task<TEntity> UpdateAsync(TId id, TEntity entity);
 
         Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);

src/JsonApiDotNetCore/Data/IEntityWriteRepository.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Models;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage;
 
@@ -32,6 +34,7 @@ public static bool EntityIsTracked(this DbContext context, IIdentifiable entity)
             return GetTrackedEntity(context, entity) != null;
         }
 
+
         /// <summary>
         /// Determines whether or not EF is already tracking an entity of the same Type and Id
         /// and returns that entity.

src/JsonApiDotNetCore/Extensions/DbContextExtensions.cs

@@ -4,6 +4,7 @@
 using JsonApiDotNetCore.Middleware;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCore.Extensions
@@ -21,6 +22,12 @@ public static IApplicationBuilder UseJsonApi(this IApplicationBuilder app, bool
             if (useMvc)
                 app.UseMvc();
 
+            using (var scope = app.ApplicationServices.CreateScope())
+            {
+                var inverseRelationshipResolver = scope.ServiceProvider.GetService<IInverseRelationships>();
+                inverseRelationshipResolver?.Resolve();
+            }
+
             return app;
         }
 

src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs

@@ -155,6 +155,9 @@ public static void AddJsonApiInternals(
             services.AddScoped<IControllerContext, Services.ControllerContext>();
             services.AddScoped<IDocumentBuilderOptionsProvider, DocumentBuilderOptionsProvider>();
 
+            services.AddScoped<IInverseRelationships, InverseRelationships>();
+
+
             // services.AddScoped<IActionFilter, TypeMatchFilter>();
         }
 

src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs

@@ -8,6 +8,42 @@ namespace JsonApiDotNetCore.Extensions
 {
     internal static class TypeExtensions
     {
+        /// <summary>
+        /// Extension to use the LINQ AddRange method on an IList
+        /// </summary>
+        public static void AddRange<T>(this IList list, IEnumerable<T> items)
+        {
+            if (list == null) throw new ArgumentNullException(nameof(list));
+            if (items == null) throw new ArgumentNullException(nameof(items));
+
+            if (list is List<T>)
+            {
+                ((List<T>)list).AddRange(items);
+            }
+            else
+            {
+                foreach (var item in items)
+                {
+                    list.Add(item);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Extension to use the LINQ cast method in a non-generic way:
+        /// <code>
+        /// Type targetType = typeof(TEntity)
+        /// ((IList)myList).Cast(targetType).
+        /// </code>
+        /// </summary>
+        public static IEnumerable Cast(this IEnumerable source, Type type)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            return TypeHelper.ConvertCollection(source.Cast<object>(), type);
+        }
+
         public static Type GetElementType(this IEnumerable enumerable)
         {
             var enumerableTypes = enumerable.GetType()

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections;
 using System.IO;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Mvc.Formatters;
@@ -37,7 +39,7 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             {
                 var body = GetRequestBody(context.HttpContext.Request.Body);
 
-                object model =null;
+                object model = null;
 
                 if (_jsonApiContext.IsRelationshipPath)
                 {
@@ -48,10 +50,29 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
                     model = _deSerializer.Deserialize(body);
                 }
 
+
                 if (model == null)
                 {
                     _logger?.LogError("An error occurred while de-serializing the payload");
                 }
+
+                if (context.HttpContext.Request.Method == "PATCH")
+                {
+                    bool idMissing;
+                    if (model is IList list)
+                    {
+                        idMissing = CheckForId(list);
+                    }
+                    else
+                    {
+                        idMissing = CheckForId(model);
+                    }
+                    if (idMissing)
+                    {
+                        _logger?.LogError("Payload must include id attribute");
+                        throw new JsonApiException(400, "Payload must include id attribute");
+                    }
+                }
                 return InputFormatterResult.SuccessAsync(model);
             }
             catch (Exception ex)
@@ -62,6 +83,40 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             }
         }
 
+        /// <summary> Checks if the deserialized payload has an ID included </summary
+        private bool CheckForId(object model)
+        {
+            if (model == null) return false;
+            if (model is ResourceObject ro)
+            {
+                if (string.IsNullOrEmpty(ro.Id)) return true;
+            }
+            else if (model is IIdentifiable identifiable)
+            {
+                if (string.IsNullOrEmpty(identifiable.StringId)) return true;
+            }
+            return false;
+        }
+
+        /// <summary> Checks if the elements in the deserialized payload have an ID included </summary
+        private bool CheckForId(IList modelList)
+        {
+            foreach (var model in modelList)
+            {
+                if (model == null) continue;
+                if (model is ResourceObject ro)
+                {
+                    if (string.IsNullOrEmpty(ro.Id)) return true;
+                }
+                else if (model is IIdentifiable identifiable)
+                {
+                    if (string.IsNullOrEmpty(identifiable.StringId)) return true;
+                }
+            }
+            return false;
+
+        }
+
         private string GetRequestBody(Stream body)
         {
             using (var reader = new StreamReader(body))

src/JsonApiDotNetCore/Formatters/JsonApiReader.cs

@@ -0,0 +1,71 @@
+using System;
+using JsonApiDotNetCore.Data;
+using JsonApiDotNetCore.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace JsonApiDotNetCore.Internal
+{
+    /// <summary>
+    /// Responsible for populating the RelationshipAttribute InverseNavigation property.
+    /// 
+    /// This service is instantiated in the configure phase of the application.
+    /// 
+    /// When using a data access layer different from EF Core, and when using ResourceHooks
+    /// that depend on the inverse navigation property (BeforeImplicitUpdateRelationship),
+    /// you will need to override this service, or pass along the inverseNavigationProperty in
+    /// the RelationshipAttribute.
+    /// </summary>
+    public interface IInverseRelationships
+    {
+        /// <summary>
+        /// This method is called upon startup by JsonApiDotNetCore. It should 
+        /// deal with resolving the inverse relationships. 
+        /// </summary>
+        void Resolve();
+    }
+
+    /// <inheritdoc />
+    public class InverseRelationships : IInverseRelationships
+    {
+        private readonly ResourceGraph _graph;
+        private readonly IDbContextResolver _resolver;
+
+        public InverseRelationships(IResourceGraph graph, IDbContextResolver resolver = null)
+        {
+            _graph = (ResourceGraph)graph;
+            _resolver = resolver;
+        }
+
+        /// <inheritdoc />
+        public void Resolve()
+        {
+            if (EntityFrameworkCoreIsEnabled())
+            {
+                DbContext context = _resolver.GetContext();
+
+                foreach (ContextEntity ce in _graph.Entities)
+                {
+                    IEntityType meta = context.Model.FindEntityType(ce.EntityType);
+                    if (meta == null) continue;
+                    foreach (var attr in ce.Relationships)
+                    {
+                        if (attr is HasManyThroughAttribute) continue;
+                        INavigation inverseNavigation = meta.FindNavigation(attr.InternalRelationshipName)?.FindInverse();
+                        attr.InverseNavigation = inverseNavigation?.Name;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// If EF Core is not being used, we're expecting the resolver to not be registered.
+        /// </summary>
+        /// <returns><c>true</c>, if entity framework core was enabled, <c>false</c> otherwise.</returns>
+        /// <param name="resolver">Resolver.</param>
+        private bool EntityFrameworkCoreIsEnabled()
+        {
+            return _resolver != null;
+        }
+    }
+}