refactor(query-set): move querying logic into the EntityRepository

jaredcnance · jaredcnance · commit 5d173c00f9a7 · 2017-01-16T16:42:19.000-06:00
diff --git a/src/JsonApiDotNetCore/Controllers/JsonApiController.cs b/src/JsonApiDotNetCore/Controllers/JsonApiController.cs
@@ -162,9 +162,14 @@ private IQueryable<T> ApplyQuery(IQueryable<T> entities)
         {
             if(!HttpContext.Request.Query.Any())
                 return entities;
+            
+            var querySet = new QuerySet<T>( _jsonApiContext);
 
-            return new QuerySet<T>( _jsonApiContext)
-                .ApplyQuery(entities);
+            entities = _entities.Filter(entities, querySet.Filter);
+
+            entities = _entities.Sort(entities, querySet.SortParameters);
+
+            return entities;
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs
@@ -1,6 +1,8 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Internal.Query;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 using Microsoft.EntityFrameworkCore;
@@ -41,31 +43,54 @@ public DefaultEntityRepository(
             _logger = loggerFactory.CreateLogger<DefaultEntityRepository<TEntity, TId>>();
         }
 
-        public IQueryable<TEntity> Get()
+        public virtual IQueryable<TEntity> Get()
         {
             return _dbSet;
         }
 
-        public async Task<TEntity> GetAsync(TId id)
+        public virtual IQueryable<TEntity> Filter(IQueryable<TEntity> entities,  FilterQuery filterQuery)
+        {
+            if(filterQuery == null)
+                return entities;
+
+            return entities
+                .Filter(filterQuery);
+        }
+
+        public virtual IQueryable<TEntity> Sort(IQueryable<TEntity> entities, List<SortQuery> sortQueries)
+        {
+            if(sortQueries == null || sortQueries.Count == 0)
+                return entities;
+
+            var orderedEntities = entities.Sort(sortQueries[0]);
+
+            if(sortQueries.Count() > 1)
+                for(var i=1; i < sortQueries.Count(); i++)
+                    orderedEntities = orderedEntities.Sort(sortQueries[i]);
+
+            return orderedEntities;
+        }
+
+        public virtual async Task<TEntity> GetAsync(TId id)
         {
             return await _dbSet.FirstOrDefaultAsync(e => e.Id.Equals(id));
         }
 
-        public async Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName)
+        public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName)
         {
             return await _dbSet
                 .Include(relationshipName)
                 .FirstOrDefaultAsync(e => e.Id.Equals(id));
         }
 
-        public async Task<TEntity> CreateAsync(TEntity entity)
+        public virtual async Task<TEntity> CreateAsync(TEntity entity)
         {
             _dbSet.Add(entity);
             await _context.SaveChangesAsync();
             return entity;
         }
 
-        public async Task<TEntity> UpdateAsync(TId id, TEntity entity)
+        public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         {
             var oldEntity = await GetAsync(id);
 
@@ -82,7 +107,7 @@ public async Task<TEntity> UpdateAsync(TId id, TEntity entity)
             return oldEntity;
         }
 
-        public async Task<bool> DeleteAsync(TId id)
+        public virtual async Task<bool> DeleteAsync(TId id)
         {
             var entity = await GetAsync(id);
 
diff --git a/src/JsonApiDotNetCore/Data/IEntityRepository.cs b/src/JsonApiDotNetCore/Data/IEntityRepository.cs
@@ -1,5 +1,7 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Internal.Query;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Data
@@ -15,6 +17,10 @@ public interface IEntityRepository<TEntity, in TId>
     {
         IQueryable<TEntity> Get();
 
+        IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQuery filterQuery);
+
+        IQueryable<TEntity> Sort(IQueryable<TEntity> entities, List<SortQuery> sortQueries);
+
         Task<TEntity> GetAsync(TId id);
 
         Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName);
diff --git a/src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs b/src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs
@@ -1,7 +1,6 @@
 using System;
 using JsonApiDotNetCore.Internal;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Mvc.Infrastructure;
 using Microsoft.AspNetCore.Mvc.Internal;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.DependencyInjection;
diff --git a/src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs b/src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs
@@ -1,40 +1,93 @@
 
+using System;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using JsonApiDotNetCore.Internal.Query;
 
 namespace JsonApiDotNetCore.Extensions
 {
     public static class IQueryableExtensions
     {
-        public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string propertyName)
+        public static IOrderedQueryable<TSource> Sort<TSource>(this IQueryable<TSource> source, SortQuery sortQuery)
         {
-            // LAMBDA: x => x.[PropertyName]
-            var parameter = Expression.Parameter(typeof(TSource), "x");
-            Expression property = Expression.Property(parameter, propertyName);
-            var lambda = Expression.Lambda(property, parameter);
+            if(sortQuery.Direction == SortDirection.Descending)
+                return source.OrderByDescending(sortQuery.SortedAttribute.InternalAttributeName);
+                
+            return source.OrderBy(sortQuery.SortedAttribute.InternalAttributeName);
+        }
 
-            // REFLECTION: source.OrderBy(x => x.Property)
-            var orderByMethod = typeof(Queryable).GetMethods().First(x => x.Name == "OrderBy" && x.GetParameters().Length == 2);
-            var orderByGeneric = orderByMethod.MakeGenericMethod(typeof(TSource), property.Type);
-            var result = orderByGeneric.Invoke(null, new object[] { source, lambda });
+        public static IOrderedQueryable<TSource> Sort<TSource>(this IOrderedQueryable<TSource> source, SortQuery sortQuery)
+        {
+            if(sortQuery.Direction == SortDirection.Descending)
+                return source.ThenByDescending(sortQuery.SortedAttribute.InternalAttributeName);
+                
+            return source.ThenBy(sortQuery.SortedAttribute.InternalAttributeName);
+        }
 
-            return (IOrderedQueryable<TSource>)result;
+        public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string propertyName)
+        {
+           return CallGenericOrderMethod(source, propertyName, "OrderBy");
         }
 
         public static IOrderedQueryable<TSource> OrderByDescending<TSource>(this IQueryable<TSource> source, string propertyName)
         {
-            // LAMBDA: x => x.[PropertyName]
+            return CallGenericOrderMethod(source, propertyName, "OrderByDescending");
+        }
+
+        public static IOrderedQueryable<TSource> ThenBy<TSource>(this IOrderedQueryable<TSource> source, string propertyName)
+        {
+            return CallGenericOrderMethod(source, propertyName, "ThenBy");
+        }
+
+        public static IOrderedQueryable<TSource> ThenByDescending<TSource>(this IOrderedQueryable<TSource> source, string propertyName)
+        {
+            return CallGenericOrderMethod(source, propertyName, "ThenByDescending");
+        }
+
+        private static IOrderedQueryable<TSource> CallGenericOrderMethod<TSource>(IQueryable<TSource> source, string propertyName, string method)
+        {
+             // {x}
             var parameter = Expression.Parameter(typeof(TSource), "x");
-            Expression property = Expression.Property(parameter, propertyName);
+            // {x.propertyName}
+            var property = Expression.Property(parameter, propertyName);
+            // {x=>x.propertyName}
             var lambda = Expression.Lambda(property, parameter);
 
             // REFLECTION: source.OrderBy(x => x.Property)
-            var orderByMethod = typeof(Queryable).GetMethods().First(x => x.Name == "OrderByDescending" && x.GetParameters().Length == 2);
+            var orderByMethod = typeof(Queryable).GetMethods().First(x => x.Name == method && x.GetParameters().Length == 2);
             var orderByGeneric = orderByMethod.MakeGenericMethod(typeof(TSource), property.Type);
             var result = orderByGeneric.Invoke(null, new object[] { source, lambda });
 
             return (IOrderedQueryable<TSource>)result;
         }
+
+        public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> source, FilterQuery filterQuery)
+        {
+            if(filterQuery == null)
+                return source;
+
+            var concreteType = typeof(TSource);
+            var property = concreteType.GetProperty(filterQuery.FilteredAttribute.InternalAttributeName);
+
+            if (property == null)
+                throw new ArgumentException($"'{filterQuery.FilteredAttribute.InternalAttributeName}' is not a valid property of '{concreteType}'");
+
+            // convert the incoming value to the target value type
+            // "1" -> 1
+            var convertedValue = Convert.ChangeType(filterQuery.PropertyValue, property.PropertyType);
+            // {model}
+            var parameter = Expression.Parameter(concreteType, "model");
+            // {model.Id}
+            var left = Expression.PropertyOrField(parameter, property.Name);
+            // {1}
+            var right = Expression.Constant(convertedValue, property.PropertyType);
+            // {model.Id == 1}
+            var body = Expression.Equal(left, right);
+
+            var lambda = Expression.Lambda<Func<TSource, bool>>(body, parameter);
+
+            return source.Where(lambda);
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Internal/JsonApiRouteHandler.cs b/src/JsonApiDotNetCore/Internal/JsonApiRouteHandler.cs
@@ -36,9 +36,7 @@ public JsonApiRouteHandler(
         public VirtualPathData GetVirtualPath(VirtualPathContext context)
         {
             if (context == null)
-            {
                 throw new ArgumentNullException(nameof(context));
-            }
 
             // We return null here because we're not responsible for generating the url, the route is.
             return null;
@@ -47,9 +45,7 @@ public VirtualPathData GetVirtualPath(VirtualPathContext context)
         public Task RouteAsync(RouteContext context)
         {
             if (context == null)
-            {
                 throw new ArgumentNullException(nameof(context));
-            }
 
             var candidates = _actionSelector.SelectCandidates(context);
             if (candidates == null || candidates.Count == 0)
diff --git a/src/JsonApiDotNetCore/Internal/Query/QuerySet.cs b/src/JsonApiDotNetCore/Internal/Query/QuerySet.cs
@@ -1,10 +1,6 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
 using JsonApiDotNetCore.Services;
-using JsonApiDotNetCore.Extensions;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
@@ -79,61 +75,5 @@ private AttrAttribute GetAttribute(string propertyName)
                     attr.InternalAttributeName.ToLower() == propertyName.ToLower()
             );
         }
-
-        public IQueryable<T> ApplyQuery(IQueryable<T> entities)
-        {
-            entities = ApplyFilter(entities);
-            entities = ApplySort(entities);
-            return entities;
-        }
-
-        private IQueryable<T> ApplyFilter(IQueryable<T> entities)
-        {
-            if(Filter == null)
-                return entities;
-
-            var expression = GetEqualityExpressionForProperty(entities, 
-                Filter.FilteredAttribute.InternalAttributeName, Filter.PropertyValue);
-
-            return entities.Where(expression);
-        }
-
-        private IQueryable<T> ApplySort(IQueryable<T> entities)
-        {
-            if(SortParameters == null || SortParameters.Count == 0)
-                return entities;
-            
-            SortParameters.ForEach(sortParam => {
-                if(sortParam.Direction == SortDirection.Ascending)
-                    entities = entities.OrderBy(sortParam.SortedAttribute.InternalAttributeName);
-                else
-                    entities = entities.OrderByDescending(sortParam.SortedAttribute.InternalAttributeName);
-            });
-
-            return entities;
-        }
-
-        private Expression<Func<T, bool>> GetEqualityExpressionForProperty(IQueryable<T> query, string param, object value)
-        {
-            var currentType = query.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);
-
-            return Expression.Lambda<Func<T, bool>>(body, prm);
-        }
     }
 }
diff --git a/src/JsonApiDotNetCoreExample/README.md b/src/JsonApiDotNetCoreExample/README.md

Original file line number	Diff line number	Diff line change
`@@ -162,9 +162,14 @@ private IQueryable<T> ApplyQuery(IQueryable<T> entities)`
`162`	`162`	`{`
`163`	`163`	`if(!HttpContext.Request.Query.Any())`
`164`	`164`	`return entities;`
	`165`	`+`
	`166`	`+ var querySet = new QuerySet<T>( _jsonApiContext);`
`165`	`167`
`166`		`- return new QuerySet<T>( _jsonApiContext)`
`167`		`- .ApplyQuery(entities);`
	`168`	`+ entities = _entities.Filter(entities, querySet.Filter);`
	`169`	`+`
	`170`	`+ entities = _entities.Sort(entities, querySet.SortParameters);`
	`171`	`+`
	`172`	`+ return entities;`
`168`	`173`	`}`
`169`	`174`	`}`
`170`	`175`	`}`