feat(*): prepping for serialization

Author: jaredcnance

src/JsonApiDotNetCore/Controllers/JsonApiController.cs

@@ -5,6 +5,7 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 
 namespace JsonApiDotNetCore.Controllers
 {
@@ -25,7 +26,8 @@ public JsonApiController(
             _jsonApiContext = jsonApiContext;
 
             _logger = loggerFactory.CreateLogger<JsonApiController<T>>();
-            _logger.LogInformation("JsonApiController activated");
+            _logger.LogInformation($@"JsonApiController activated with ContextGraph: 
+                {JsonConvert.SerializeObject(jsonApiContext.ContextGraph)}");
         }
 
         public JsonApiController(

src/JsonApiDotNetCore/Formatters/JsonApiInputFormatter.cs

@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Serialization;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json;
+
+namespace JsonApiDotNetCore.Formatters
+{
+    public class JsonApiInputFormatter : IInputFormatter
+    {
+
+        public bool CanRead(InputFormatterContext context)
+        {
+            if (context == null)
+                throw new ArgumentNullException(nameof(context));
+
+            var contentTypeString = context.HttpContext.Request.ContentType;
+
+            return string.IsNullOrEmpty(contentTypeString) || contentTypeString == "application/vnd.api+json";
+        }
+
+        public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
+        {
+            if (context == null)
+                throw new ArgumentNullException(nameof(context));
+
+            var request = context.HttpContext.Request;
+
+            if (request.ContentLength == 0)
+            {
+                return InputFormatterResult.SuccessAsync(null);
+            }
+
+            try
+            {
+                var body = GetRequestBody(context.HttpContext.Request.Body);
+                var contextGraph = context.HttpContext.RequestServices.GetService<IContextGraph>();
+                var model = JsonApiDeSerializer.Deserialize(body, contextGraph);
+
+                return InputFormatterResult.SuccessAsync(model);
+            }
+            catch (JsonSerializationException)
+            {
+                context.HttpContext.Response.StatusCode = 422;
+                return InputFormatterResult.FailureAsync();
+            }
+        }
+
+        private string GetRequestBody(Stream body)
+        {
+            using (var reader = new StreamReader(body))
+            {
+                return reader.ReadToEnd();
+            }
+        }
+    }
+}

src/JsonApiDotNetCore/Internal/AttrAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace JsonApiDotNetCore.Internal
+{
+    public class AttrAttribute : Attribute
+    {
+        public AttrAttribute(string publicName)
+        {
+            PublicAttributeName = publicName;
+        }
+
+        public string PublicAttributeName { get; set; }
+        public string InternalAttributeName { get; set; }
+    }
+}

src/JsonApiDotNetCore/Internal/ContextEntity.cs

@@ -7,6 +7,7 @@ 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; }
     }
 }

src/JsonApiDotNetCore/Internal/ContextGraph.cs

@@ -9,6 +9,13 @@ public class ContextGraph<T> : IContextGraph where T : DbContext
     {
         public List<ContextEntity> Entities { get; set; }
 
+        public ContextEntity GetContextEntity(string dbSetName)
+        {
+            return Entities
+                .FirstOrDefault(e => 
+                    e.EntityName.ToLower() == dbSetName.ToLower());
+        }
+
         public object GetRelationship<TParent>(TParent entity, string relationshipName)
         {
             var parentEntityType = typeof(TParent);

src/JsonApiDotNetCore/Internal/ContextGraphBuilder.cs

@@ -32,21 +32,39 @@ private void _getFirstLevelEntities()
 
             foreach(var property in contextProperties)
             {
-                var type = property.PropertyType;
+                var dbSetType = property.PropertyType;
 
-                if (type.GetTypeInfo().IsGenericType 
-                    && type.GetGenericTypeDefinition() == typeof(DbSet<>))
+                if (dbSetType.GetTypeInfo().IsGenericType 
+                    && dbSetType.GetGenericTypeDefinition() == typeof(DbSet<>))
                 {
+                    var entityType = dbSetType.GetGenericArguments()[0];
                     entities.Add(new ContextEntity {
                         EntityName = property.Name,
-                        EntityType = type.GetGenericArguments()[0]
+                        EntityType = entityType,
+                        Attributes = _getAttributes(entityType)
                     });
                 }                    
             }
 
             _entities = entities;
         }
 
+        private List<AttrAttribute> _getAttributes(Type entityType)
+        {
+            var attributes = new List<AttrAttribute>();
+            
+            var properties = entityType.GetProperties();
+
+            foreach(var prop in properties)
+            {
+                var attribute = (AttrAttribute)prop.GetCustomAttribute(typeof(AttrAttribute));
+                if(attribute == null) continue;
+                attribute.InternalAttributeName = prop.Name;
+                attributes.Add(attribute);
+            }
+            return attributes;
+        }
+
         private void _loadRelationships()
         {          
             _entities.ForEach(entity => {

src/JsonApiDotNetCore/Internal/IContextGraph.cs

@@ -4,5 +4,6 @@ public interface IContextGraph
     {
         object GetRelationship<TParent>(TParent entity, string relationshipName);
         string GetRelationshipName<TParent>(string relationshipName);
+        ContextEntity GetContextEntity(string dbSetName);
     }
 }

src/JsonApiDotNetCore/Models/Document.cs

@@ -0,0 +1,7 @@
+namespace JsonApiDotNetCore.Models
+{
+    public class Document
+    {
+        public DocumentData Data { get; set; }
+    }
+}

src/JsonApiDotNetCore/Models/DocumentData.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace JsonApiDotNetCore.Models
+{
+    public class DocumentData
+    {
+       public string Type { get; set; }
+       public string Id { get; set; }
+       public Dictionary<string,object> Attributes { get; set; }
+    }
+}

src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
+using Newtonsoft.Json;
+
+namespace JsonApiDotNetCore.Serialization
+{
+    public static class JsonApiDeSerializer
+    {
+        public static object Deserialize(string requestBody, IContextGraph contextGraph)
+        {
+            var document = JsonConvert.DeserializeObject<Document>(requestBody);
+            var contextEntity = contextGraph.GetContextEntity(document.Data.Type);
+            
+            var entity = Activator.CreateInstance(contextEntity.EntityType);
+            
+            entity = _setEntityAttributes(entity, contextEntity, document.Data.Attributes);
+
+            return null;
+        }
+
+        private static object _setEntityAttributes(
+            object entity, ContextEntity contextEntity, Dictionary<string, object> attributeValues)
+        {
+            var entityProperties = entity.GetType().GetProperties();
+
+            foreach(var attr in  contextEntity.Attributes)
+            {
+                var entityProperty = entityProperties.FirstOrDefault(p => p.Name == attr.InternalAttributeName);
+                
+                if(entityProperty == null)
+                    throw new ArgumentException($"{contextEntity.EntityType.Name} does not contain an attribute named {attr.InternalAttributeName}", nameof(entity));
+                
+                object newValue;
+                if (attributeValues.TryGetValue(attr.PublicAttributeName, out newValue))
+                {
+                    Convert.ChangeType(newValue, entityProperty.PropertyType);
+                    entityProperty.SetValue(entity, newValue);
+                }
+            }
+
+            return entity;
+        }
+    }
+}