test(patch): can patch relationship links

jaredcnance · jaredcnance · commit 43bd9e6cc406 · 2017-03-01T16:31:16.000-06:00
prior to this commit there was nothing to handle updating relationships
diff --git a/src/JsonApiDotNetCore/Controllers/JsonApiController.cs b/src/JsonApiDotNetCore/Controllers/JsonApiController.cs
@@ -159,10 +159,40 @@ public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
             var updatedEntity = await _entities.UpdateAsync(id, entity);
 
             if(updatedEntity == null)  return NotFound();
-            
+
             return Ok(updatedEntity);
         }
 
+        [HttpPatch("{id}/relationships/{relationshipName}")]
+        public virtual async Task<IActionResult> PatchRelationshipsAsync(TId id, string relationshipName, [FromBody] List<DocumentData> relationships)
+        {
+            relationshipName = _jsonApiContext.ContextGraph
+                .GetRelationshipName<T>(relationshipName.ToProperCase());
+
+            if (relationshipName == null)
+            {
+                _logger?.LogInformation($"Relationship name not specified returning 422");
+                return UnprocessableEntity();
+            }
+
+            var entity = await _entities.GetAndIncludeAsync(id, relationshipName);
+
+            if (entity == null)
+                return NotFound();
+
+            var relationship = _jsonApiContext.ContextGraph
+                .GetContextEntity(typeof(T))
+                .Relationships
+                .FirstOrDefault(r => r.RelationshipName == relationshipName);
+
+            var relationshipIds = relationships.Select(r=>r.Id);
+            
+            await _entities.UpdateRelationshipsAsync(entity, relationship, relationshipIds);
+
+            return Ok();
+            
+        }
+
         [HttpDelete("{id}")]
         public virtual async Task<IActionResult> DeleteAsync(TId id)
         {
diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs
@@ -105,7 +105,13 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
 
             await _context.SaveChangesAsync();
 
-            return oldEntity;
+        return oldEntity;
+        }
+
+        public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)
+        {
+            var genericProcessor = GenericProcessorFactory.GetProcessor(relationship.BaseType, _context);
+            await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 
         public virtual async Task<bool> DeleteAsync(TId id)
diff --git a/src/JsonApiDotNetCore/Data/IEntityRepository.cs b/src/JsonApiDotNetCore/Data/IEntityRepository.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Internal.Query;
 using JsonApiDotNetCore.Models;
 
@@ -33,6 +34,8 @@ public interface IEntityRepository<TEntity, in TId>
 
         Task<TEntity> UpdateAsync(TId id, TEntity entity);
 
+        Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);
+
         Task<bool> DeleteAsync(TId id);
     }
 }
diff --git a/src/JsonApiDotNetCore/Formatters/JsonApiInputFormatter.cs b/src/JsonApiDotNetCore/Formatters/JsonApiInputFormatter.cs
@@ -41,7 +41,9 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             {
                 var body = GetRequestBody(context.HttpContext.Request.Body);
                 var jsonApiContext = GetService<IJsonApiContext>(context);
-                var model = JsonApiDeSerializer.Deserialize(body, jsonApiContext);
+                var model = jsonApiContext.IsRelationshipPath ? 
+                    JsonApiDeSerializer.DeserializeRelationship(body, jsonApiContext) :
+                    JsonApiDeSerializer.Deserialize(body, jsonApiContext);
 
                 if(model == null)
                     logger?.LogError("An error occurred while de-serializing the payload");
diff --git a/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs
@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Internal
+{
+    public class GenericProcessor<T> : IGenericProcessor where T : class, IIdentifiable
+    {
+        private readonly DbContext _context;
+        public GenericProcessor(DbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds)
+        {
+            var relationshipType = relationship.BaseType;
+
+            var entities = _context.GetDbSet<T>().Where(x => relationshipIds.Contains(x.Id.ToString())).ToList();
+            relationship.SetValue(parent, entities);
+
+            await _context.SaveChangesAsync();
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Internal/Generics/GenericProcessorFactory.cs b/src/JsonApiDotNetCore/Internal/Generics/GenericProcessorFactory.cs
@@ -0,0 +1,19 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Internal
+{
+    /// <summary>
+    /// Used to generate a generic operations processor when the types
+    /// are not know until runtime. The typical use case would be for
+    /// accessing relationship data.
+    /// </summary>
+    public static class GenericProcessorFactory
+    {
+        public static IGenericProcessor GetProcessor(Type type, DbContext dbContext)
+        {
+            var repositoryType = typeof(GenericProcessor<>).MakeGenericType(type);
+            return (IGenericProcessor)Activator.CreateInstance(repositoryType, dbContext);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs b/src/JsonApiDotNetCore/Internal/Generics/IGenericProcessor.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace JsonApiDotNetCore.Internal
+{
+    public interface IGenericProcessor
+    {
+        Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Internal/Relationship.cs b/src/JsonApiDotNetCore/Internal/Relationship.cs
@@ -1,10 +1,30 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using JsonApiDotNetCore.Extensions;
 
 namespace JsonApiDotNetCore.Internal
 {
     public class Relationship
     {
         public Type Type { get; set; }
+        public Type BaseType { get {
+            return (Type.GetInterfaces().Contains(typeof(IEnumerable))) ?
+                 Type.GenericTypeArguments[0] :
+                 Type;            
+        } }
+
         public string RelationshipName { get; set; }
+
+        public void SetValue(object entity, object newValue)
+        {
+            var propertyInfo = entity
+                .GetType()
+                .GetProperty(RelationshipName);
+            
+            propertyInfo.SetValue(entity, newValue);        
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs b/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs
@@ -7,6 +7,7 @@
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace JsonApiDotNetCore.Serialization
 {
@@ -15,12 +16,21 @@ public static class JsonApiDeSerializer
         public static object Deserialize(string requestBody, IJsonApiContext context)
         {
             var document = JsonConvert.DeserializeObject<Document>(requestBody);
-
             var entity = DataToObject(document.Data, context);
-
             return entity;
         }
 
+        public static object DeserializeRelationship(string requestBody, IJsonApiContext context)
+        {
+            var data = JToken.Parse(requestBody)["data"];
+
+            if(data is JArray)
+                return data.ToObject<List<DocumentData>>();
+
+            return new List<DocumentData> { data.ToObject<DocumentData>() };
+        }
+
+
         public static List<TEntity> DeserializeList<TEntity>(string requestBody, IJsonApiContext context)
         {
             var documents = JsonConvert.DeserializeObject<Documents>(requestBody);
diff --git a/src/JsonApiDotNetCore/Services/IJsonApiContext.cs b/src/JsonApiDotNetCore/Services/IJsonApiContext.cs
@@ -15,6 +15,8 @@ public interface IJsonApiContext
         QuerySet QuerySet { get; set; }
         bool IsRelationshipData { get; set; }
         List<string> IncludedRelationships { get; set; }
+        bool IsRelationshipPath { get; }
         PageManager PageManager { get; set; }
+        
     }
 }
diff --git a/src/JsonApiDotNetCore/Services/JsonApiContext.cs b/src/JsonApiDotNetCore/Services/JsonApiContext.cs
@@ -27,12 +27,14 @@ public JsonApiContext(
         public string BasePath { get; set; }
         public QuerySet QuerySet { get; set; }
         public bool IsRelationshipData { get; set; }
+        public bool IsRelationshipPath { get; private set; }
         public List<string> IncludedRelationships { get; set; }
         public PageManager PageManager { get; set; }
 
         public IJsonApiContext ApplyContext<T>()
         {
             var context = _httpContextAccessor.HttpContext;
+            var path = context.Request.Path.Value.Split('/');
 
             RequestEntity = ContextGraph.GetContextEntity(typeof(T));
             
@@ -45,7 +47,7 @@ public IJsonApiContext ApplyContext<T>()
             var linkBuilder = new LinkBuilder(this);
             BasePath = linkBuilder.GetBasePath(context, RequestEntity.EntityName);
             PageManager = GetPageManager();
-            
+            IsRelationshipPath = path[path.Length - 2] == "relationships";
             return this;
         }
 
diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DocumentTests/Included.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DocumentTests/Included.cs
@@ -106,6 +106,7 @@ public async Task GET_Included_Contains_SideloadedData_OneToMany()
         {
             // arrange
             _context.People.RemoveRange(_context.People); // ensure all people have todo-items
+            _context.TodoItems.RemoveRange(_context.TodoItems);
             var person = _personFaker.Generate();
             var todoItem = _todoItemFaker.Generate();
             todoItem.Owner = person;
diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/UpdatingRelationshipsTests.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/UpdatingRelationshipsTests.cs
@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Bogus;
+using DotNetCoreDocs;
+using DotNetCoreDocs.Writers;
+using JsonApiDotNetCoreExample;
+using JsonApiDotNetCoreExample.Data;
+using JsonApiDotNetCoreExample.Models;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Xunit;
+using Person = JsonApiDotNetCoreExample.Models.Person;
+
+namespace JsonApiDotNetCoreExampleTests.Acceptance.Spec
+{
+    [Collection("WebHostCollection")]
+    public class UpdatingRelationshipsTests
+    {
+        private DocsFixture<Startup, JsonDocWriter> _fixture;
+        private AppDbContext _context;
+        private Faker<Person> _personFaker;
+        private Faker<TodoItem> _todoItemFaker;
+
+        public UpdatingRelationshipsTests(DocsFixture<Startup, JsonDocWriter> fixture)
+        {
+            _fixture = fixture;
+            _context = fixture.GetService<AppDbContext>();
+            _personFaker = new Faker<Person>()
+                .RuleFor(t => t.FirstName, f => f.Name.FirstName())
+                .RuleFor(t => t.LastName, f => f.Name.LastName());
+
+            _todoItemFaker = new Faker<TodoItem>()
+                .RuleFor(t => t.Description, f => f.Lorem.Sentence())
+                .RuleFor(t => t.Ordinal, f => f.Random.Number());
+        }
+
+        [Fact]
+        public async Task Can_Update_ToManyRelationship_ThroughLink()
+        {
+            // arrange
+            var person = _personFaker.Generate();
+            _context.People.Add(person);
+
+            var todoItem = _todoItemFaker.Generate();
+            _context.TodoItems.Add(todoItem);
+
+            _context.SaveChanges();
+
+            var builder = new WebHostBuilder()
+                .UseStartup<Startup>();
+
+            var server = new TestServer(builder);
+            var client = server.CreateClient();
+            
+            var content = new
+            {
+                data = new List<object>
+                {
+                    new {
+                        type = "todo-items",
+                        id = $"{todoItem.Id}"
+                    }
+                }
+            };
+
+            var httpMethod = new HttpMethod("PATCH");
+            var route = $"/api/v1/people/{person.Id}/relationships/todo-items";
+            var request = new HttpRequestMessage(httpMethod, route);
+
+            request.Content = new StringContent(JsonConvert.SerializeObject(content));
+            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/vnd.api+json");
+
+            // Act
+            var response = await client.SendAsync(request);
+            var personsTodoItems = _context.People.Include(p => p.TodoItems).Single(p => p.Id == person.Id).TodoItems;
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotEmpty(personsTodoItems);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Linq;`
`3`	`3`	`using System.Threading.Tasks;`
	`4`	`+using JsonApiDotNetCore.Internal;`
`4`	`5`	`using JsonApiDotNetCore.Internal.Query;`
`5`	`6`	`using JsonApiDotNetCore.Models;`
`6`	`7`
`@@ -33,6 +34,8 @@ public interface IEntityRepository<TEntity, in TId>`
`33`	`34`
`34`	`35`	`Task<TEntity> UpdateAsync(TId id, TEntity entity);`
`35`	`36`
	`37`	`+ Task UpdateRelationshipsAsync(object parent, Relationship relationship, IEnumerable<string> relationshipIds);`
	`38`	`+`
`36`	`39`	`Task<bool> DeleteAsync(TId id);`
`37`	`40`	`}`
`38`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@ public interface IJsonApiContext`
`15`	`15`	`QuerySet QuerySet { get; set; }`
`16`	`16`	`bool IsRelationshipData { get; set; }`
`17`	`17`	`List<string> IncludedRelationships { get; set; }`
	`18`	`+ bool IsRelationshipPath { get; }`
`18`	`19`	`PageManager PageManager { get; set; }`
	`20`	`+`
`19`	`21`	`}`
`20`	`22`	`}`