finish relational routing

Author: jaredcnance

JsonApiDotNetCore/Abstractions/ModelAccessor.cs

@@ -1,19 +1,26 @@
 using System;
+using System.Collections;
 using System.ComponentModel;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using JsonApiDotNetCore.Attributes;
+using JsonApiDotNetCore.Extensions;
 
 namespace JsonApiDotNetCore.Abstractions
 {
   public static class ModelAccessor
   {
-    public static Type GetTypeFromModelRelationshipName(object model, string relationshipName)
+    public static Type GetTypeFromModelRelationshipName(Type modelType, string relationshipName)
     {
-      return model.GetType().GetProperties().Where(propertyInfo => propertyInfo.GetMethod.IsVirtual).ToList().FirstOrDefault(
-        virtualProperty => virtualProperty.Name == relationshipName)?.PropertyType;
+      var properties = modelType.GetProperties().Where(propertyInfo => propertyInfo.GetMethod.IsVirtual).ToList();
+      var relationshipType = properties.FirstOrDefault(
+        virtualProperty => virtualProperty.Name.ToCamelCase() == relationshipName.ToCamelCase())?.PropertyType;
+      if(relationshipType.GetTypeInfo().IsGenericType)
+      {
+        return relationshipType.GetGenericArguments().Single();
+      }
+      return relationshipType;
     }
-
   }
 }

JsonApiDotNetCore/Data/GenericDataAccess.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using JsonApiDotNetCore.Abstractions;
+using System.Reflection;
+using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+
+public class GenericDataAccess
+{
+  public DbSet<T> GetDbSet<T>(DbContext context) where T : class
+  {
+    return context.Set<T>();
+  }
+
+  public IQueryable<T> IncludeEntity<T>(IQueryable<T> queryable, string includedEntityName) where T : class
+  {
+    return queryable.Include(includedEntityName);
+  }
+}

JsonApiDotNetCore/Data/ResourceRepository.cs

@@ -26,19 +26,18 @@ public List<object> Get()
 
     public object Get(string id)
     {
-      var relationalRoute = _context.Route as RelationalRoute;
-      if (relationalRoute == null)
+      if (_context.Route is RelationalRoute)
       {
-        return GetEntityById(_context.Route.BaseModelType, id, null);
+        return GetRelated(id, _context.Route as RelationalRoute);
       }
-      return GetRelated(id, relationalRoute);
+      return GetEntityById(_context.Route.BaseModelType, id, null);
     }
 
     private object GetRelated(string id, RelationalRoute relationalRoute)
     {
       // HACK: this would rely on lazy loading to work...will probably fail
-      var entity = GetEntityById(relationalRoute.RelationalType, id, relationalRoute.RelationshipName);
-      return relationalRoute.RelationalType.GetProperties().FirstOrDefault(pi => pi.Name.ToCamelCase() == relationalRoute.RelationshipName.ToCamelCase()).GetValue(entity);
+      var entity = GetEntityById(relationalRoute.BaseModelType, id, relationalRoute.RelationshipName);
+      return relationalRoute.BaseModelType.GetProperties().FirstOrDefault(pi => pi.Name.ToCamelCase() == relationalRoute.RelationshipName.ToCamelCase()).GetValue(entity);
     }
 
 
@@ -52,30 +51,21 @@ private object GetEntityById(Type modelType, string id, string includedRelations
     {
       // HACK: I _believe_ by casting to IEnumerable, we are loading all records into memory, if so... find a better way...
       //        Also, we are making a BIG assumption that the resource has an attribute Id and not ResourceId which is allowed by EF
-      var methodToCall = typeof(ResourceRepository).GetMethods().Single(method => method.Name.Equals("GetDbSet"));
-      var genericMethod = methodToCall.MakeGenericMethod(modelType);
-      genericMethod.Invoke(genericMethod, null);
-      var dbSet = genericMethod.Invoke(this, null);
+      var dataAccessorInstance = Activator.CreateInstance(typeof(GenericDataAccess));
+      var dataAccessorMethod = dataAccessorInstance.GetType().GetMethod("GetDbSet");
+      var genericMethod = dataAccessorMethod.MakeGenericMethod(modelType);
+      var dbSet = genericMethod.Invoke(dataAccessorInstance, new [] {((DbContext) _context.DbContext) });
 
       if (!string.IsNullOrEmpty(includedRelationship))
       {
-        var includeMethod = typeof(ResourceRepository).GetMethods().Single(method => method.Name.Equals("IncludeEntity"));
+        var includeMethod =  dataAccessorInstance.GetType().GetMethod("IncludeEntity");
         var genericIncludeMethod = includeMethod.MakeGenericMethod(modelType);
-        genericIncludeMethod.Invoke(genericMethod, null);
-        dbSet = genericIncludeMethod.Invoke(this, new []{ dbSet, includedRelationship });
+        dbSet = genericIncludeMethod.Invoke(dataAccessorInstance, new []{ dbSet, includedRelationship.ToProperCase() });
       }
 
       return (dbSet as IEnumerable<dynamic>).SingleOrDefault(x => x.Id.ToString() == id);
     }
 
-    private DbSet<T> GetDbSet<T>() where T : class
-    {
-      return ((DbContext) _context.DbContext).Set<T>();
-    }
 
-    private IQueryable<T> IncludeEntity<T>(IQueryable<T> queryable, string includedEntityName) where T : class
-    {
-      return queryable.Include(includedEntityName);
-    }
   }
 }

JsonApiDotNetCore/Extensions/StringExtensions.cs

@@ -14,5 +14,15 @@ public static string ToCamelCase(this string str)
       }
       return str;
     }
+    public static string ToProperCase(this string str)
+    {
+      var splittedPhraseChars = str.ToCharArray();
+      if (splittedPhraseChars.Length > 0)
+      {
+        splittedPhraseChars[0] = new string(splittedPhraseChars[0], 1).ToUpper().ToCharArray()[0];
+        return new String(splittedPhraseChars);
+      }
+      return str;
+    }
   }
 }

JsonApiDotNetCore/Routing/RouteBuilder.cs

@@ -23,13 +23,13 @@ public Route BuildFromRequest()
     {
       var remainingPathString = SetBaseRouteDefinition();
 
-      if (!remainingPathString.HasValue)
+      if (PathStringIsEmpty(remainingPathString))
       { // {baseResource}
         return new Route(_baseRouteDefinition.ModelType, _request.Method, null, _baseRouteDefinition);
       }
 
       remainingPathString = SetBaseResourceId(remainingPathString);
-      if (!remainingPathString.HasValue)
+      if (PathStringIsEmpty(remainingPathString))
       { // {baseResource}/{baseResourceId}
         return new Route(_baseRouteDefinition.ModelType, _request.Method, _baseResourceId, _baseRouteDefinition);
       }
@@ -46,6 +46,11 @@ public Route BuildFromRequest()
       return new RelationalRoute(_baseRouteDefinition.ModelType, _request.Method, _baseResourceId, _baseRouteDefinition, relationshipType, relatedResource);
     }
 
+    private bool PathStringIsEmpty(PathString pathString)
+    {
+      return pathString.HasValue ? string.IsNullOrEmpty(pathString.ToString().TrimStart('/')) : false;
+    }
+
     private PathString SetBaseRouteDefinition()
     {
       foreach (var rte in _configuration.Routes)

JsonApiDotNetCore/Services/JsonApiSerializer.cs

@@ -1,4 +1,5 @@
-using System.Collections;
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
@@ -10,18 +11,33 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using System.Reflection;
+using JsonApiDotNetCore.Routing;
 
 namespace JsonApiDotNetCore.Services
 {
   public class JsonApiSerializer
   {
     private readonly JsonApiContext _context;
     private readonly JsonApiModelConfiguration _jsonApiModelConfiguration;
+    private string _entityName;
+    private Type _entityType;
 
     public JsonApiSerializer(JsonApiContext jsonApiContext, JsonApiModelConfiguration configuration)
     {
       _context = jsonApiContext;
       _jsonApiModelConfiguration = configuration;
+      _entityName = GetEntityName();
+      _entityType = GetEntityType();
+    }
+
+    private string GetEntityName() {
+      return (!(_context.Route is RelationalRoute) ? _context.Route.BaseRouteDefinition.ContextPropertyName
+      : _jsonApiModelConfiguration.Routes.Single(r=> r.ModelType == ((RelationalRoute)_context.Route).RelationalType).ContextPropertyName).ToCamelCase();
+    }
+
+    private Type GetEntityType() {
+      return !(_context.Route is RelationalRoute) ? _context.Route.BaseRouteDefinition.ModelType
+      : ((RelationalRoute)_context.Route).RelationalType;
     }
 
     public string ToJsonApiDocument(object resultValue)
@@ -66,7 +82,7 @@ private JsonApiDatum ResourceToJsonApiDatum(JsonApiContext context, IJsonApiReso
     {
       return new JsonApiDatum
       {
-        Type = context.Route.BaseRouteDefinition.ContextPropertyName.ToCamelCase(),
+        Type = _entityName,
         Id = resource.Id,
         Attributes = GetAttributesFromResource(resource),
         Links = GetJsonApiDatumLinks(context, resource),
@@ -88,21 +104,24 @@ private Dictionary<string, string> GetJsonApiDocumentLinks(JsonApiContext jsonAp
       var request = jsonApiContext.HttpContext.Request;
       var route = jsonApiContext.Route;
 
-      return DocumentBuilder.BuildSelfLink(request.Scheme, request.Host.ToString(), _jsonApiModelConfiguration.Namespace,
-        route.BaseRouteDefinition.ContextPropertyName.ToCamelCase(), route.ResourceId);
+      return new Dictionary<string, string> {
+        {
+          "self", $"{request.Scheme}://{request.Host}{request.Path}"
+        }
+      };
     }
 
     private Dictionary<string, string> GetJsonApiDatumLinks(JsonApiContext jsonApiContext, IJsonApiResource resource)
     {
       return DocumentBuilder.BuildSelfLink(jsonApiContext.HttpContext.Request.Scheme,
         jsonApiContext.HttpContext.Request.Host.ToString(), _jsonApiModelConfiguration.Namespace,
-        jsonApiContext.Route.BaseRouteDefinition.ContextPropertyName.ToCamelCase(), resource.Id);
+        _entityName, resource.Id);
     }
 
     private Dictionary<string, object> BuildRelationshipsObject(JsonApiContext jsonApiContext, IJsonApiResource resource)
     {
       var relationships = new Dictionary<string, object>();
-      jsonApiContext.Route.BaseModelType.GetProperties().Where(propertyInfo => propertyInfo.GetMethod.IsVirtual).ToList().ForEach(
+      _entityType.GetProperties().Where(propertyInfo => propertyInfo.GetMethod.IsVirtual).ToList().ForEach(
         virtualProperty =>
         {
           relationships.Add(virtualProperty.Name, GetRelationshipLinks(jsonApiContext, resource, virtualProperty.Name.ToCamelCase()));
@@ -114,7 +133,7 @@ private Dictionary<string, string> GetRelationshipLinks(JsonApiContext jsonApiCo
     {
       return DocumentBuilder.BuildRelationshipLinks(jsonApiContext.HttpContext.Request.Scheme,
         jsonApiContext.HttpContext.Request.Host.ToString(), _jsonApiModelConfiguration.Namespace,
-        jsonApiContext.Route.BaseRouteDefinition.ContextPropertyName.ToCamelCase(), resource.Id, relationshipName);
+       _entityName, resource.Id, relationshipName);
     }
   }
 }