add GenericDataAccessAbstraction

Closes #9

Author: jaredcnance

JsonApiDotNetCore/Data/GenericDataAccess.cs

@@ -19,7 +19,7 @@ public IQueryable<T> IncludeEntity<T>(IQueryable<T> queryable, string includedEn
       return queryable.Include(includedEntityName);
     }
 
-    public T SingleOrDefault<T>(object query, string param, string value)
+    public T SingleOrDefault<T>(object query, string param, object value)
     {
       var queryable = (IQueryable<T>) query;
       var currentType = queryable.ElementType;
@@ -30,9 +30,16 @@ public T SingleOrDefault<T>(object query, string param, string value)
         throw new ArgumentException($"'{param}' is not a valid property of '{currentType}'");
       }
 
-      var prm = Expression.Parameter(currentType, property.Name);
-      var left = Expression.Convert(Expression.PropertyOrField(prm, property.Name), typeof(string));
-      var right = Expression.Constant(1, property.PropertyType);
+      // convert the incoming value to the target value type
+      // "1" -> 1
+      var convertedValue = Convert.ChangeType(value, property.PropertyType);
+      // {model}
+      var prm = Expression.Parameter(currentType, "model");
+      // {model.Id}
+      var left = Expression.PropertyOrField(prm, property.Name);
+      // {1}
+      var right = Expression.Constant(convertedValue, property.PropertyType);
+      // {model.Id == 1}
       var body = Expression.Equal(left, right);
       var where = Expression.Lambda<Func<T, bool>>(body, prm);
 

JsonApiDotNetCore/Data/GenericDataAccessAbstraction.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Reflection;
+using System.Linq;
+using System.Linq.Expressions;
+using JsonApiDotNetCore.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Data
+{
+  public class GenericDataAccessAbstraction
+  {
+    private GenericDataAccess _dataAccessorInstance;
+    private DbContext _dbContext;
+    private Type _modelType;
+    private string _includedRelationship;
+    public GenericDataAccessAbstraction(object dbContext, Type modelType, string includedRelationship)
+    {
+      _dataAccessorInstance = (GenericDataAccess)Activator.CreateInstance(typeof(GenericDataAccess));
+      _dbContext = (DbContext) dbContext;
+      _modelType = modelType;
+      _includedRelationship = includedRelationship?.ToProperCase();
+    }
+
+    public object SingleOrDefault(string id)
+    {
+      var dbSet = GetDbSet();
+      if (!string.IsNullOrEmpty(_includedRelationship))
+      {
+        dbSet = IncludeRelationshipInContext(dbSet);
+      }
+      var dataAccessorSingleOrDefaultMethod = _dataAccessorInstance.GetType().GetMethod("SingleOrDefault");
+      var genericSingleOrDefaultMethod = dataAccessorSingleOrDefaultMethod.MakeGenericMethod(_modelType);
+      return genericSingleOrDefaultMethod.Invoke(_dataAccessorInstance, new[] { dbSet, "Id", id });
+    }
+
+    private object GetDbSet()
+    {
+      var dataAccessorGetDbSetMethod = _dataAccessorInstance.GetType().GetMethod("GetDbSet");
+      var genericGetDbSetMethod = dataAccessorGetDbSetMethod.MakeGenericMethod(_modelType);
+      return genericGetDbSetMethod.Invoke(_dataAccessorInstance, new [] { _dbContext });
+    }
+
+    private object IncludeRelationshipInContext(object dbSet)
+    {
+      var includeMethod =  _dataAccessorInstance.GetType().GetMethod("IncludeEntity");
+      var genericIncludeMethod = includeMethod.MakeGenericMethod(_modelType);
+      return genericIncludeMethod.Invoke(_dataAccessorInstance, new []{ dbSet, _includedRelationship });
+    }
+
+  }
+}

JsonApiDotNetCore/Data/ResourceRepository.cs

@@ -43,26 +43,7 @@ private IQueryable GetDbSetFromContext(string propName)
 
     private object GetEntityById(Type modelType, string id, string includedRelationship)
     {
-      // get generic dbSet
-      var dataAccessorInstance = Activator.CreateInstance(typeof(GenericDataAccess));
-      var dataAccessorGetDbSetMethod = dataAccessorInstance.GetType().GetMethod("GetDbSet");
-      var genericGetDbSetMethod = dataAccessorGetDbSetMethod.MakeGenericMethod(modelType);
-      var dbSet = genericGetDbSetMethod.Invoke(dataAccessorInstance, new [] {((DbContext) _context.DbContext) });
-
-      // include relationships if requested
-      if (!string.IsNullOrEmpty(includedRelationship))
-      {
-        var includeMethod =  dataAccessorInstance.GetType().GetMethod("IncludeEntity");
-        var genericIncludeMethod = includeMethod.MakeGenericMethod(modelType);
-        dbSet = genericIncludeMethod.Invoke(dataAccessorInstance, new []{ dbSet, includedRelationship.ToProperCase() });
-      }
-
-      // get the SingleOrDefault value by Id
-      var dataAccessorSingleOrDefaultMethod = dataAccessorInstance.GetType().GetMethod("SingleOrDefault");
-      var genericSingleOrDefaultMethod = dataAccessorSingleOrDefaultMethod.MakeGenericMethod(modelType);
-      var entity = genericSingleOrDefaultMethod.Invoke(dataAccessorInstance, new[] { dbSet, "Id", id });
-
-      return entity;
+      return new GenericDataAccessAbstraction(_context.DbContext, modelType, includedRelationship).SingleOrDefault(id);;
     }
 
     public void Add(object entity)