Additional filter operations: isnull and isnotnull

README.md

@@ -75,3 +75,41 @@ public class Startup
     }
 }
 ```
+
+### Development
+
+Restore all nuget packages with:
+
+```bash
+dotnet restore
+```
+
+#### Testing
+
+Running tests locally requires access to a postgresql database.  
+If you have docker installed, this can be propped up via: 
+
+```bash
+docker run --rm --name jsonapi-dotnet-core-testing \
+  -e POSTGRES_DB=JsonApiDotNetCoreExample \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -p 5432:5432 \
+  postgres
+```
+
+And then to run the tests:
+
+```bash
+dotnet test
+```
+
+#### Cleaning
+
+Sometimes the compiled files can be dirty / corrupt from other branches / failed builds.
+If your bash prompt supports the globstar, you can recursively delete the `bin` and `obj` directories:
+
+```bash
+shopt -s globstar
+rm -rf **/bin && rm -rf **/obj
+```

src/Examples/JsonApiDotNetCoreExample/Models/TodoItem.cs

@@ -24,6 +24,12 @@ public TodoItem()
 
         [Attr("achieved-date", isFilterable: false, isSortable: false)]
         public DateTime? AchievedDate { get; set; }
+
+
+        [Attr("updated-date")]
+        public DateTime? UpdatedDate { get; set; }
+
+
 
         public int? OwnerId { get; set; }
         public int? AssigneeId { get; set; }

src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs

@@ -113,31 +113,56 @@ public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> sourc
 
             var concreteType = typeof(TSource);
             var property = concreteType.GetProperty(filterQuery.FilteredAttribute.InternalAttributeName);
+            var op = filterQuery.FilterOperation;
 
             if (property == null)
                 throw new ArgumentException($"'{filterQuery.FilteredAttribute.InternalAttributeName}' is not a valid property of '{concreteType}'");
 
             try
             {
-                if (filterQuery.FilterOperation == FilterOperations.@in || filterQuery.FilterOperation == FilterOperations.nin)
+                if (op == FilterOperations.@in || op == FilterOperations.nin)
                 {
                     string[] propertyValues = filterQuery.PropertyValue.Split(',');
-                    var lambdaIn = ArrayContainsPredicate<TSource>(propertyValues, property.Name, filterQuery.FilterOperation);
+                    var lambdaIn = ArrayContainsPredicate<TSource>(propertyValues, property.Name, op);
 
                     return source.Where(lambdaIn);
                 }
+                else if (op == FilterOperations.@is || op == FilterOperations.isnot) {
+                    var parameter = Expression.Parameter(concreteType, "model");
+                    // {model.Id}
+                    var left = Expression.PropertyOrField(parameter, property.Name);
+                    var right = Expression.Constant(filterQuery.PropertyValue, typeof(string));
+
+                    var body = GetFilterExpressionLambda(left, right, op);
+                    var lambda = Expression.Lambda<Func<TSource, bool>>(body, parameter);
+
+                    return source.Where(lambda);
+                }
                 else
-                {   // convert the incoming value to the target value type
+                {   
+                    var isNullabe = IsNullable(property.PropertyType);
+                    var propertyValue = filterQuery.PropertyValue;
+                    var value = propertyValue;
+
+                    if (op == FilterOperations.@isnot || op == FilterOperations.isnot)
+                    {
+                        if (isNullabe && propertyValue == "null") 
+                        {
+                            value = null;
+                        }
+                    }
+
+                    // convert the incoming value to the target value type
                     // "1" -> 1
-                    var convertedValue = TypeHelper.ConvertType(filterQuery.PropertyValue, property.PropertyType);
+                    var convertedValue = TypeHelper.ConvertType(value, 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 = GetFilterExpressionLambda(left, right, filterQuery.FilterOperation);
+                    var body = GetFilterExpressionLambda(left, right, op);
 
                     var lambda = Expression.Lambda<Func<TSource, bool>>(body, parameter);
 
@@ -204,6 +229,9 @@ public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> sourc
             }
         }
 
+        private static bool IsNullable(Type type) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
+
+
         private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperations operation)
         {
             Expression body;
@@ -236,6 +264,14 @@ private static Expression GetFilterExpressionLambda(Expression left, Expression
                 case FilterOperations.ne:
                     body = Expression.NotEqual(left, right);
                     break;
+                case FilterOperations.isnot:
+                    // {model.Id != null}
+                    body = Expression.NotEqual(left, right);
+                    break;
+                case FilterOperations.@is:
+                    // {model.Id == null}
+                    body = Expression.Equal(left, right);
+                    break;
                 default:
                     throw new JsonApiException(500, $"Unknown filter operation {operation}");
             }

src/JsonApiDotNetCore/Internal/Query/FilterOperations.cs

@@ -11,6 +11,8 @@ public enum FilterOperations
         like = 5,
         ne = 6,
         @in = 7, // prefix with @ to use keyword
-        nin = 8
+        nin = 8,
+        @is = 9,
+        isnot = 10
     }
 }

test/JsonApiDotNetCoreExampleTests/Acceptance/TodoItemsControllerTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
@@ -90,6 +91,52 @@ public async Task Can_Filter_TodoItems()
                 Assert.Equal(todoItem.Ordinal, todoItemResult.Ordinal);
         }
 
+        [Fact]
+        public async Task Can_Filter_TodoItems_Using_IsNot_Operator()
+        {
+            // Arrange
+            var todoItem = _todoItemFaker.Generate();
+            todoItem.UpdatedDate = new DateTime();
+            _context.TodoItems.Add(todoItem);
+            _context.SaveChanges();
+
+            var httpMethod = new HttpMethod("GET");
+            var route = $"/api/v1/todo-items?filter[updated-date]=isnot:null";
+            var request = new HttpRequestMessage(httpMethod, route);
+
+            // Act
+            var response = await _fixture.Client.SendAsync(request);
+            var body = await response.Content.ReadAsStringAsync();
+            var deserializedBody = _fixture.GetService<IJsonApiDeSerializer>().DeserializeList<TodoItem>(body);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotEmpty(deserializedBody);
+        }
+
+        [Fact]
+        public async Task Can_Filter_TodoItems_Using_Is_Operator()
+        {
+            // Arrange
+            var todoItem = _todoItemFaker.Generate();
+            todoItem.UpdatedDate = null;
+            _context.TodoItems.Add(todoItem);
+            _context.SaveChanges();
+
+            var httpMethod = new HttpMethod("GET");
+            var route = $"/api/v1/todo-items?filter[updated-date]=is:null";
+            var request = new HttpRequestMessage(httpMethod, route);
+
+            // Act
+            var response = await _fixture.Client.SendAsync(request);
+            var body = await response.Content.ReadAsStringAsync();
+            var deserializedBody = _fixture.GetService<IJsonApiDeSerializer>().DeserializeList<TodoItem>(body);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotEmpty(deserializedBody);
+        }
+
         [Fact]
         public async Task Can_Filter_TodoItems_Using_Like_Operator()
         {