feat(filtering): add support for operators other than equality

Author: jaredcnance

README.md

@@ -145,3 +145,25 @@ add to the service collection in `Startup.ConfigureServices` like so:
 ```
 services.AddScoped<IEntityRepository<MyEntity,Guid>, MyEntityRepository>();
 ```
+
+
+## Filtering
+
+You can filter resources by attributes using the `filter` query parameter. 
+By default, all attributes are filterable.
+The filtering strategy we have selected, uses the following form:
+
+```
+?filter[attribute]=value
+```
+
+For operations other than equality, the query can be prefixed with an operation
+identifier):
+
+```
+?filter[attribute]=eq:value
+?filter[attribute]=lt:value
+?filter[attribute]=gt:value
+?filter[attribute]=le:value
+?filter[attribute]=ge:value
+```

src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Internal.Query;
 
 namespace JsonApiDotNetCore.Extensions
@@ -11,23 +12,23 @@ public static class IQueryableExtensions
     {
         public static IOrderedQueryable<TSource> Sort<TSource>(this IQueryable<TSource> source, SortQuery sortQuery)
         {
-            if(sortQuery.Direction == SortDirection.Descending)
+            if (sortQuery.Direction == SortDirection.Descending)
                 return source.OrderByDescending(sortQuery.SortedAttribute.InternalAttributeName);
-                
+
             return source.OrderBy(sortQuery.SortedAttribute.InternalAttributeName);
         }
 
         public static IOrderedQueryable<TSource> Sort<TSource>(this IOrderedQueryable<TSource> source, SortQuery sortQuery)
         {
-            if(sortQuery.Direction == SortDirection.Descending)
+            if (sortQuery.Direction == SortDirection.Descending)
                 return source.ThenByDescending(sortQuery.SortedAttribute.InternalAttributeName);
-                
+
             return source.ThenBy(sortQuery.SortedAttribute.InternalAttributeName);
         }
 
         public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string propertyName)
         {
-           return CallGenericOrderMethod(source, propertyName, "OrderBy");
+            return CallGenericOrderMethod(source, propertyName, "OrderBy");
         }
 
         public static IOrderedQueryable<TSource> OrderByDescending<TSource>(this IQueryable<TSource> source, string propertyName)
@@ -47,7 +48,7 @@ public static IOrderedQueryable<TSource> ThenByDescending<TSource>(this IOrdered
 
         private static IOrderedQueryable<TSource> CallGenericOrderMethod<TSource>(IQueryable<TSource> source, string propertyName, string method)
         {
-             // {x}
+            // {x}
             var parameter = Expression.Parameter(typeof(TSource), "x");
             // {x.propertyName}
             var property = Expression.Property(parameter, propertyName);
@@ -64,7 +65,7 @@ private static IOrderedQueryable<TSource> CallGenericOrderMethod<TSource>(IQuery
 
         public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> source, FilterQuery filterQuery)
         {
-            if(filterQuery == null)
+            if (filterQuery == null)
                 return source;
 
             var concreteType = typeof(TSource);
@@ -73,21 +74,51 @@ public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> sourc
             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);
+            try
+            {
+                // 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);
+
+                var body = Expression.Equal(left, right);
+                switch (filterQuery.FilterOperation)
+                {
+                    case FilterOperations.eq:
+                        // {model.Id == 1}
+                        body = Expression.Equal(left, right);
+                        break;
+                    case FilterOperations.lt:
+                        // {model.Id < 1}
+                        body = Expression.LessThan(left, right);
+                        break;
+                    case FilterOperations.gt:
+                        // {model.Id > 1}
+                        body = Expression.GreaterThan(left, right);
+                        break;
+                    case FilterOperations.le:
+                        // {model.Id <= 1}
+                        body = Expression.LessThanOrEqual(left, right);
+                        break;
+                    case FilterOperations.ge:
+                        // {model.Id <= 1}
+                        body = Expression.GreaterThanOrEqual(left, right);
+                        break;
+                }
+
+                var lambda = Expression.Lambda<Func<TSource, bool>>(body, parameter);
+
+                return source.Where(lambda);
+            }
+            catch (FormatException)
+            {
+                throw new JsonApiException("400", $"Could not cast {filterQuery.PropertyValue} to {property.PropertyType.Name}");
+            }
         }
     }
 }

src/JsonApiDotNetCore/Internal/Query/FilterOperations.cs

@@ -0,0 +1,11 @@
+namespace JsonApiDotNetCore.Internal.Query
+{
+    public enum FilterOperations
+    {
+        eq = 0,
+        lt = 1,
+        gt = 2,
+        le = 3,
+        ge = 4
+    }
+}

src/JsonApiDotNetCore/Internal/Query/FilterQuery.cs

@@ -2,13 +2,15 @@ namespace JsonApiDotNetCore.Internal.Query
 {
     public class FilterQuery
     {
-        public FilterQuery(AttrAttribute filteredAttribute, string propertyValue)
+        public FilterQuery(AttrAttribute filteredAttribute, string propertyValue, FilterOperations filterOperation)
         {
             FilteredAttribute = filteredAttribute;
             PropertyValue = propertyValue;
+            FilterOperation = filterOperation;
         }
 
         public AttrAttribute FilteredAttribute { get; set; }
         public string PropertyValue { get; set; }
+        public FilterOperations FilterOperation { get; set; }
     }
 }

src/JsonApiDotNetCore/Internal/Query/QuerySet.cs

@@ -32,7 +32,7 @@ private void BuildQuerySet(IQueryCollection query)
             {
                 if (pair.Key.StartsWith("filter"))
                 {
-                    Filters.Add(ParseFilterQuery(pair.Key, pair.Value));
+                    Filters.AddRange(ParseFilterQuery(pair.Key, pair.Value));
                     continue;
                 }
 
@@ -54,16 +54,53 @@ private void BuildQuerySet(IQueryCollection query)
             }
         }
 
-        private FilterQuery ParseFilterQuery(string key, string value)
+        private List<FilterQuery> ParseFilterQuery(string key, string value)
         {
             // expected input = filter[id]=1
+            // expected input = filter[id]=eq:1
+            var queries = new List<FilterQuery>();
+
             var propertyName = key.Split('[', ']')[1].ToProperCase();
             var attribute = GetAttribute(propertyName);
 
             if (attribute == null)
                 throw new JsonApiException("400", $"{propertyName} is not a valid property.");
 
-            return new FilterQuery(attribute, value);
+            var values = value.Split(',');
+            foreach(var val in values)
+                queries.Add(ParseFilterOperation(attribute, val));
+
+            return queries;
+        }
+
+        private FilterQuery ParseFilterOperation(AttrAttribute attribute, string value)
+        {
+            if(value.Length < 3)
+                return new FilterQuery(attribute, value, FilterOperations.eq);
+             
+            var prefix = value.Substring(0, 3);
+
+            if(prefix[2] != ':')
+                return new FilterQuery(attribute, value, FilterOperations.eq);
+            
+            // remove prefix from value
+            value = value.Substring(3, value.Length - 3);
+
+            switch(prefix)
+            {
+                case "eq:":
+                    return new FilterQuery(attribute, value, FilterOperations.eq);
+                case "lt:":
+                    return new FilterQuery(attribute, value, FilterOperations.lt);
+                case "gt:":
+                    return new FilterQuery(attribute, value, FilterOperations.gt);
+                case "le:":
+                    return new FilterQuery(attribute, value, FilterOperations.le);
+                case "ge:":
+                    return new FilterQuery(attribute, value, FilterOperations.ge);
+            }
+
+            throw new JsonApiException("400", $"Invalid filter prefix '{prefix}'");
         }
 
         private PageQuery ParsePageQuery(string key, string value)

src/JsonApiDotNetCore/project.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.6",
+  "version": "0.2.7",
 
   "dependencies": {
     "Microsoft.NETCore.App": {

src/JsonApiDotNetCoreExample/Migrations/20170131150223_AddOrdinalToTodoItems.Designer.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace JsonApiDotNetCoreExample.Migrations
+{
+    public partial class AddOrdinalToTodoItems : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<long>(
+                name: "Ordinal",
+                table: "TodoItems",
+                nullable: false,
+                defaultValue: 0L);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Ordinal",
+                table: "TodoItems");
+        }
+    }
+}

src/JsonApiDotNetCoreExample/Migrations/20170131150223_AddOrdinalToTodoItems.cs

@@ -37,6 +37,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.Property<string>("Description");
 
+                    b.Property<long>("Ordinal");
+
                     b.Property<int>("OwnerId");
 
                     b.HasKey("Id");

src/JsonApiDotNetCoreExample/Migrations/AppDbContextModelSnapshot.cs

@@ -9,6 +9,9 @@ public class TodoItem : Identifiable<int>
 
         [Attr("description")]
         public string Description { get; set; }
+
+        [Attr("ordinal")]
+        public long Ordinal { get; set; }
 
         public int OwnerId { get; set; }
         public virtual Person Owner { get; set; }