Nested sort - Init

Author: Milos

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -19,6 +19,9 @@ public class Person : Identifiable, IHasMeta
         [Attr("last-name")]
         public string LastName { get; set; }
 
+        [Attr("age")]
+        public int Age { get; set; }
+
         [HasMany("todo-items")]
         public virtual List<TodoItem> TodoItems { get; set; }
 

src/JsonApiDotNetCore/Builders/DocumentBuilder.cs

@@ -142,7 +142,7 @@ private bool ShouldIncludeAttribute(AttrAttribute attr, object attributeValue)
             return OmitNullValuedAttribute(attr, attributeValue) == false
                    && ((_jsonApiContext.QuerySet == null
                        || _jsonApiContext.QuerySet.Fields.Count == 0)
-                       || _jsonApiContext.QuerySet.Fields.Contains(attr.InternalAttributeName));
+                       || _jsonApiContext.QuerySet.Fields.Any(i => i.Attribute == attr.InternalAttributeName));
         }
 
         private bool OmitNullValuedAttribute(AttrAttribute attr, object attributeValue)

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -58,7 +58,7 @@ public DefaultEntityRepository(
         public virtual IQueryable<TEntity> Get()
         {
             if (_jsonApiContext.QuerySet?.Fields != null && _jsonApiContext.QuerySet.Fields.Count > 0)
-                return _dbSet.Select(_jsonApiContext.QuerySet?.Fields);
+                return _dbSet.Select(_jsonApiContext.QuerySet.Fields);
 
             return _dbSet;
         }
@@ -72,7 +72,7 @@ public virtual IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQu
         /// <inheritdoc />
         public virtual IQueryable<TEntity> Sort(IQueryable<TEntity> entities, List<SortQuery> sortQueries)
         {
-            return entities.Sort(sortQueries);
+            return entities.Sort(_jsonApiContext, sortQueries);
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs

@@ -4,34 +4,22 @@
 
 namespace JsonApiDotNetCore.Internal.Query
 {
-    public class AttrFilterQuery : BaseFilterQuery
+    public class AttrFilterQuery : AttrQuery
     {
-        private readonly IJsonApiContext _jsonApiContext;
-
         public AttrFilterQuery(
             IJsonApiContext jsonApiContext,
             FilterQuery filterQuery)
+            :base(jsonApiContext, filterQuery)
         {
-            _jsonApiContext = jsonApiContext;
-
-            var attribute = GetAttribute(filterQuery.Attribute);
-
-            if (attribute == null)
-                throw new JsonApiException(400, $"'{filterQuery.Attribute}' is not a valid attribute.");
-
-            if (attribute.IsFilterable == false)
-                throw new JsonApiException(400, $"Filter is not allowed for attribute '{attribute.PublicAttributeName}'.");
+            if (Attribute.IsFilterable == false)
+                throw new JsonApiException(400, $"Filter is not allowed for attribute '{Attribute.PublicAttributeName}'.");
 
-            FilteredAttribute = attribute;
             PropertyValue = filterQuery.Value;
-            FilterOperation = GetFilterOperation(filterQuery.Operation);
+            FilterOperation = FilterOperations.GetFilterOperation(filterQuery.Operation);
         }
 
-        public AttrAttribute FilteredAttribute { get; }
         public string PropertyValue { get; }
-        public FilterOperations FilterOperation { get; }
+        public FilterOperationsEnum FilterOperation { get; }
 
-        private AttrAttribute GetAttribute(string attribute) =>
-            _jsonApiContext.RequestEntity.Attributes.FirstOrDefault(attr => attr.Is(attribute));
     }
 }

src/JsonApiDotNetCore/Internal/Query/AttrFilterQuery.cs

@@ -0,0 +1,36 @@
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using System;
+using System.Linq;
+
+namespace JsonApiDotNetCore.Internal.Query
+{
+    public class AttrQuery
+    {
+        private readonly IJsonApiContext _jsonApiContext;
+
+        public AttrQuery(IJsonApiContext jsonApiContext, QueryAttribute query)
+        {
+            _jsonApiContext = jsonApiContext;
+            Attribute = GetAttribute(query.Attribute);
+        }
+
+        public AttrAttribute Attribute { get; }
+
+        private AttrAttribute GetAttribute(string attribute)
+        {
+            try
+            {
+                return _jsonApiContext
+                    .RequestEntity
+                    .Attributes
+                    .Single(attr => attr.Is(attribute));
+            }
+            catch (InvalidOperationException e)
+            {
+                throw new JsonApiException(400, $"Attribute '{attribute}' does not exist on resource '{_jsonApiContext.RequestEntity.EntityName}'", e);
+            }
+        }
+
+    }
+}

src/JsonApiDotNetCore/Internal/Query/AttrQuery.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+
+namespace JsonApiDotNetCore.Internal.Query
+{
+    public class AttrSortQuery : AttrQuery
+    {
+        public AttrSortQuery(
+            IJsonApiContext jsonApiContext,
+            SortQuery sortQuery)
+            :base(jsonApiContext, sortQuery)
+        {
+            if (Attribute.IsSortable == false)
+                throw new JsonApiException(400, $"Sort is not allowed for attribute '{Attribute.PublicAttributeName}'.");
+
+            Direction = sortQuery.Direction;
+        }
+
+        public SortDirection Direction { get; set; }
+
+    }
+}

src/JsonApiDotNetCore/Internal/Query/AttrSortQuery.cs

@@ -1,7 +1,9 @@
 // ReSharper disable InconsistentNaming
+using System;
+
 namespace JsonApiDotNetCore.Internal.Query
 {
-    public enum FilterOperations
+    public enum FilterOperationsEnum
     {
         eq = 0,
         lt = 1,
@@ -15,4 +17,33 @@ public enum FilterOperations
         isnull = 9,
         isnotnull = 10
     }
+
+    public class FilterOperations
+    {
+        public static FilterOperationsEnum GetFilterOperation(string prefix)
+        {
+            if (prefix.Length == 0) return FilterOperationsEnum.eq;
+
+            if (Enum.TryParse(prefix, out FilterOperationsEnum opertion) == false)
+                throw new JsonApiException(400, $"Invalid filter prefix '{prefix}'");
+
+            return opertion;
+        }
+
+        public static string GetFilterOperationFromQuery(string query)
+        {
+            var values = query.Split(QueryConstants.COLON);
+
+            if (values.Length == 1)
+                return string.Empty;
+
+            var operation = values[0];
+            // remove prefix from value
+            if (Enum.TryParse(operation, out FilterOperationsEnum op) == false)
+                return string.Empty;
+
+            return operation;
+        }
+
+    }
 }

src/JsonApiDotNetCore/Internal/Query/BaseFilterQuery.cs

@@ -3,21 +3,20 @@
 
 namespace JsonApiDotNetCore.Internal.Query
 {
-    public class FilterQuery
+    public class FilterQuery: QueryAttribute
     {
         public FilterQuery(string attribute, string value, string operation)
+            :base(attribute)
         {
-            Attribute = attribute;
             Key = attribute.ToProperCase();
             Value = value;
             Operation = operation;
         }
 
         [Obsolete("Key has been replaced by '" + nameof(Attribute) + "'. Members should be located by their public name, not by coercing the provided value to the internal name.")]
         public string Key { get; set; }
-        public string Attribute { get; }
         public string Value { get; set; }
         public string Operation { get; set; }
-        public bool IsAttributeOfRelationship => Attribute.Contains(".");
+
     }
 }