add where data accessor

Author: jaredcnance

JsonApiDotNetCore/Data/GenericDataAccess.cs

@@ -45,5 +45,32 @@ public T SingleOrDefault<T>(object query, string param, object value)
 
       return queryable.SingleOrDefault(where);
     }
+
+    public IQueryable<T> Where<T>(object query, string param, object value)
+    {
+      var queryable = (IQueryable<T>) query;
+      var currentType = queryable.ElementType;
+      var property = currentType.GetProperty(param);
+
+      if (property == null)
+      {
+        throw new ArgumentException($"'{param}' is not a valid property of '{currentType}'");
+      }
+
+      // 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);
+
+      return queryable.Where(where);
+    }
   }
 }

JsonApiDotNetCore/Data/GenericDataAccessAbstraction.cs

@@ -21,23 +21,35 @@ public GenericDataAccessAbstraction(object dbContext, Type modelType, string inc
       _includedRelationship = includedRelationship?.ToProperCase();
     }
 
-    public object SingleOrDefault(string id)
+    public object SingleOrDefault(string propertyName, string value)
     {
       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 });
+      return InvokeGenericDataAccessMethod("SingleOrDefault", new[] { dbSet, propertyName, value });
+    }
+
+    public object Filter(string propertyName, string value)
+    {
+      var dbSet = GetDbSet();
+      return InvokeGenericDataAccessMethod("Where", new[] { dbSet, propertyName, value });
+    }
+
+    private object InvokeGenericDataAccessMethod(string methodName, params object[] propertyValues)
+    {
+      var dataAccessorMethod = _dataAccessorInstance.GetType().GetMethod(methodName);
+      var genericDataAccessorMethod = dataAccessorMethod.MakeGenericMethod(_modelType);
+      return genericDataAccessorMethod.Invoke(_dataAccessorInstance, propertyValues);
     }
 
     private object GetDbSet()
     {
       var dataAccessorGetDbSetMethod = _dataAccessorInstance.GetType().GetMethod("GetDbSet");
       var genericGetDbSetMethod = dataAccessorGetDbSetMethod.MakeGenericMethod(_modelType);
-      return genericGetDbSetMethod.Invoke(_dataAccessorInstance, new [] { _dbContext });
+      var dbSet = genericGetDbSetMethod.Invoke(_dataAccessorInstance, new [] { _dbContext });
+      if (!string.IsNullOrEmpty(_includedRelationship))
+      {
+        dbSet = IncludeRelationshipInContext(dbSet);
+      }
+      return dbSet;
     }
 
     private object IncludeRelationshipInContext(object dbSet)

JsonApiDotNetCore/Data/ResourceRepository.cs

@@ -43,7 +43,7 @@ private IQueryable GetDbSetFromContext(string propName)
 
     private object GetEntityById(Type modelType, string id, string includedRelationship)
     {
-      return new GenericDataAccessAbstraction(_context.DbContext, modelType, includedRelationship).SingleOrDefault(id);;
+      return new GenericDataAccessAbstraction(_context.DbContext, modelType, includedRelationship).SingleOrDefault("Id", id);
     }
 
     public void Add(object entity)

JsonApiDotNetCoreTests/Data/UnitTests/GenericDataAccessTests.cs

@@ -36,5 +36,31 @@ public void SingleOrDefault_Fetches_SingleItemFromContext()
             Assert.Equal(1, item1.Id);
             Assert.Equal(2, item2.Id);
         }
+
+        [Fact]
+        public void Where_FetchesRecords_WherePropertyValueEquals_ProvidedValue()
+        {
+            // arrange
+            var data = new List<TodoItem>
+            {
+                new TodoItem { Id = 1, Name = "AAA" },
+                new TodoItem { Id = 2, Name = "AAA" },
+                new TodoItem { Id = 3, Name = "BBB" }
+            }.AsQueryable();
+
+            var mockSet = new Mock<DbSet<TodoItem>>();
+            mockSet.As<IQueryable<TodoItem>>().Setup(m => m.Provider).Returns(data.Provider);
+            mockSet.As<IQueryable<TodoItem>>().Setup(m => m.Expression).Returns(data.Expression);
+            mockSet.As<IQueryable<TodoItem>>().Setup(m => m.ElementType).Returns(data.ElementType);
+            mockSet.As<IQueryable<TodoItem>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
+
+            var genericDataAccess = new GenericDataAccess();
+
+            // act
+            var items = genericDataAccess.Where<TodoItem>(mockSet.Object, "Name", "AAA");
+
+            // assert
+            Assert.Equal(2, items.Count());
+        }
     }
 }