Nested sort

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/Data/DefaultEntityRepository.cs

@@ -90,10 +90,10 @@ public virtual IQueryable<TEntity> Get()
         /// <inheritdoc />
         public virtual IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQuery filterQuery)
         {
-            if(_resourceDefinition != null) 
+            if (_resourceDefinition != null)
             {
                 var defaultQueryFilters = _resourceDefinition.GetQueryFilters();
-                if(defaultQueryFilters != null && defaultQueryFilters.TryGetValue(filterQuery.Attribute, out var defaultQueryFilter) == true)
+                if (defaultQueryFilters != null && defaultQueryFilters.TryGetValue(filterQuery.Attribute, out var defaultQueryFilter) == true)
                 {
                     return defaultQueryFilter(entities, filterQuery.Value);
                 }
@@ -106,15 +106,15 @@ public virtual IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQu
         public virtual IQueryable<TEntity> Sort(IQueryable<TEntity> entities, List<SortQuery> sortQueries)
         {
             if (sortQueries != null && sortQueries.Count > 0)
-                return entities.Sort(sortQueries);
-            
-            if(_resourceDefinition != null) 
+                return entities.Sort(_jsonApiContext, sortQueries);
+
+            if (_resourceDefinition != null)
             {
                 var defaultSortOrder = _resourceDefinition.DefaultSort();
-                if(defaultSortOrder != null && defaultSortOrder.Count > 0)
+                if (defaultSortOrder != null && defaultSortOrder.Count > 0)
                 {
-                    foreach(var sortProp in defaultSortOrder)
-                    { 
+                    foreach (var sortProp in defaultSortOrder)
+                    {
                         // this is dumb...add an overload, don't allocate for no reason
                         entities.Sort(new SortQuery(sortProp.Item2, sortProp.Item1));
                     }
@@ -189,10 +189,10 @@ private void AttachHasManyPointers(TEntity entity)
             var relationships = _jsonApiContext.HasManyRelationshipPointers.Get();
             foreach (var relationship in relationships)
             {
-                if(relationship.Key is HasManyThroughAttribute hasManyThrough)
+                if (relationship.Key is HasManyThroughAttribute hasManyThrough)
                     AttachHasManyThrough(entity, hasManyThrough, relationship.Value);
                 else
-                    AttachHasMany(relationship.Key as HasManyAttribute, relationship.Value);                
+                    AttachHasMany(relationship.Key as HasManyAttribute, relationship.Value);
             }
         }
 
@@ -289,15 +289,15 @@ public virtual async Task<bool> DeleteAsync(TId id)
         /// <inheritdoc />
         public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
-            if(string.IsNullOrWhiteSpace(relationshipName)) throw new JsonApiException(400, "Include parameter must not be empty if provided");
+            if (string.IsNullOrWhiteSpace(relationshipName)) throw new JsonApiException(400, "Include parameter must not be empty if provided");
 
             var relationshipChain = relationshipName.Split('.');
 
             // variables mutated in recursive loop
             // TODO: make recursive method
             string internalRelationshipPath = null;
             var entity = _jsonApiContext.RequestEntity;
-            for(var i = 0; i < relationshipChain.Length; i++)
+            for (var i = 0; i < relationshipChain.Length; i++)
             {
                 var requestedRelationship = relationshipChain[i];
                 var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == requestedRelationship);
@@ -315,7 +315,7 @@ public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string
                 internalRelationshipPath = (internalRelationshipPath == null)
                     ? relationship.RelationshipPath
                     : $"{internalRelationshipPath}.{relationship.RelationshipPath}";
-                
+
                 if(i < relationshipChain.Length)
                     entity = _jsonApiContext.ResourceGraph.GetContextEntity(relationship.Type);
             }

src/JsonApiDotNetCore/Internal/Query/AttrFilterQuery.cs

@@ -1,37 +1,26 @@
-using System.Linq;
+using System;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
     public class AttrFilterQuery : BaseFilterQuery
     {
-        private readonly IJsonApiContext _jsonApiContext;
-
         public AttrFilterQuery(
             IJsonApiContext jsonApiContext,
             FilterQuery filterQuery)
+            : base(jsonApiContext, filterQuery)
         {
-            _jsonApiContext = jsonApiContext;
-
-            var attribute = GetAttribute(filterQuery.Attribute);
-
-            if (attribute == null)
+            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);
+            FilteredAttribute = Attribute;
         }
 
-        public AttrAttribute FilteredAttribute { get; }
-        public string PropertyValue { get; }
-        public FilterOperations FilterOperation { get; }
-
-        private AttrAttribute GetAttribute(string attribute) =>
-            _jsonApiContext.RequestEntity.Attributes.FirstOrDefault(attr => attr.Is(attribute));
+        [Obsolete("Use " + nameof(BaseAttrQuery.Attribute) + " insetad.")]
+        public AttrAttribute FilteredAttribute { get; set; }
     }
 }

src/JsonApiDotNetCore/Internal/Query/AttrSortQuery.cs

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

src/JsonApiDotNetCore/Internal/Query/BaseAttrQuery.cs

@@ -0,0 +1,56 @@
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using System.Linq;
+
+namespace JsonApiDotNetCore.Internal.Query
+{
+    /// <summary>
+    /// Abstract class to make available shared properties of all query implementations
+    /// It elimines boilerplate of providing specified type(AttrQuery or RelatedAttrQuery) 
+    /// while filter and sort operations and eliminates plenty of methods to keep DRY principles 
+    /// </summary>
+    public abstract class BaseAttrQuery
+    {
+        private readonly IJsonApiContext _jsonApiContext;
+
+        public BaseAttrQuery(IJsonApiContext jsonApiContext, BaseQuery baseQuery)
+        {
+            _jsonApiContext = jsonApiContext;
+            if (baseQuery.IsAttributeOfRelationship)
+            {
+                Relationship = GetRelationship(baseQuery.Relationship);
+                Attribute = GetAttribute(Relationship, baseQuery.Attribute);
+            }
+            else
+            {
+                Attribute = GetAttribute(baseQuery.Attribute);
+            }
+
+        }
+
+        public AttrAttribute Attribute { get; }
+        public RelationshipAttribute Relationship { get; }
+        public bool IsAttributeOfRelationship => Relationship != null;
+
+        public string GetPropertyPath()
+        {
+            if (IsAttributeOfRelationship)
+                return string.Format("{0}.{1}", Relationship.InternalRelationshipName, Attribute.InternalAttributeName);
+            else
+                return Attribute.InternalAttributeName;
+        }
+
+        private AttrAttribute GetAttribute(string attribute)
+            => _jsonApiContext.RequestEntity.Attributes.FirstOrDefault(attr => attr.Is(attribute));
+
+        private RelationshipAttribute GetRelationship(string propertyName)
+            => _jsonApiContext.RequestEntity.Relationships.FirstOrDefault(r => r.Is(propertyName));
+
+        private AttrAttribute GetAttribute(RelationshipAttribute relationship, string attribute)
+        {
+            var relatedContextExntity = _jsonApiContext.ResourceGraph.GetContextEntity(relationship.Type);
+            return relatedContextExntity.Attributes
+              .FirstOrDefault(a => a.Is(attribute));
+        }
+    }
+}

src/JsonApiDotNetCore/Internal/Query/BaseFilterQuery.cs

@@ -1,10 +1,23 @@
+using JsonApiDotNetCore.Services;
 using System;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
-    public class BaseFilterQuery
+    public class BaseFilterQuery : BaseAttrQuery
     {
-        protected FilterOperations GetFilterOperation(string prefix)
+        public BaseFilterQuery(
+            IJsonApiContext jsonApiContext,
+            FilterQuery filterQuery)
+        : base(jsonApiContext, filterQuery)
+        {
+            PropertyValue = filterQuery.Value;
+            FilterOperation = GetFilterOperation(filterQuery.Operation);
+        }
+
+        public string PropertyValue { get; }
+        public FilterOperations FilterOperation { get; }
+
+        private FilterOperations GetFilterOperation(string prefix)
         {
             if (prefix.Length == 0) return FilterOperations.eq;
 
@@ -13,5 +26,6 @@ protected FilterOperations GetFilterOperation(string prefix)
 
             return opertion;
         }
+
     }
 }

src/JsonApiDotNetCore/Internal/Query/BaseQuery.cs

@@ -0,0 +1,26 @@
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using System;
+using System.Linq;
+
+namespace JsonApiDotNetCore.Internal.Query
+{
+    public abstract class BaseQuery
+    {
+        public BaseQuery(string attribute)
+        {
+            var properties = attribute.Split(QueryConstants.DOT);
+            if(properties.Length > 1)
+            {
+                Relationship = properties[0];
+                Attribute = properties[1];
+            }
+            else
+                Attribute = properties[0];
+        }
+
+        public string Attribute { get; }
+        public string Relationship { get; }
+        public bool IsAttributeOfRelationship => Relationship != null;
+    }
+}

src/JsonApiDotNetCore/Internal/Query/FilterQuery.cs

@@ -1,23 +1,23 @@
 using System;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
-    public class FilterQuery
+    public class FilterQuery : BaseQuery
     {
         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(".");
+
     }
 }

src/JsonApiDotNetCore/Internal/Query/QueryConstants.cs

@@ -10,6 +10,7 @@ public static class QueryConstants {
         public const char COMMA = ',';
         public const char COLON = ':';
         public const string COLON_STR = ":";
+        public const char DOT = '.';
 
     }
-}
+}

src/JsonApiDotNetCore/Internal/Query/QuerySet.cs

@@ -10,4 +10,4 @@ public class QuerySet
         public List<string> IncludedRelationships { get; set; } = new List<string>();
         public List<string> Fields { get; set; } = new List<string>();
     }
-}
+}

src/JsonApiDotNetCore/Internal/Query/RelatedAttrFilterQuery.cs

@@ -1,50 +1,33 @@
-using System.Linq;
+using System;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 
 namespace JsonApiDotNetCore.Internal.Query
 {
     public class RelatedAttrFilterQuery : BaseFilterQuery
     {
-        private readonly IJsonApiContext _jsonApiContext;
-
         public RelatedAttrFilterQuery(
             IJsonApiContext jsonApiContext,
             FilterQuery filterQuery)
+            :base(jsonApiContext, filterQuery)
         {
-            _jsonApiContext = jsonApiContext;
+            if (Relationship == null)
+                throw new JsonApiException(400, $"{filterQuery.Relationship} is not a valid relationship on {jsonApiContext.RequestEntity.EntityName}.");
 
-            var relationshipArray = filterQuery.Attribute.Split('.');
-            var relationship = GetRelationship(relationshipArray[0]);
-            if (relationship == null)
-                throw new JsonApiException(400, $"{relationshipArray[1]} is not a valid relationship on {relationshipArray[0]}.");
-
-            var attribute = GetAttribute(relationship, relationshipArray[1]);
-            if (attribute == null)
+            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}'.");
 
-            FilteredRelationship = relationship;
-            FilteredAttribute = attribute;
-            PropertyValue = filterQuery.Value;
-            FilterOperation = GetFilterOperation(filterQuery.Operation);
+            FilteredRelationship = Relationship;
+            FilteredAttribute = Attribute;
         }
 
+        [Obsolete("Use " + nameof(Attribute) + " instead.")]
         public AttrAttribute FilteredAttribute { get; set; }
-        public string PropertyValue { get; set; }
-        public FilterOperations FilterOperation { get; set; }
-        public RelationshipAttribute FilteredRelationship { get; }
-
-        private RelationshipAttribute GetRelationship(string propertyName)
-            => _jsonApiContext.RequestEntity.Relationships.FirstOrDefault(r => r.Is(propertyName));
 
-        private AttrAttribute GetAttribute(RelationshipAttribute relationship, string attribute)
-        {
-            var relatedContextExntity = _jsonApiContext.ResourceGraph.GetContextEntity(relationship.Type);
-            return relatedContextExntity.Attributes
-              .FirstOrDefault(a => a.Is(attribute));
-        }
+        [Obsolete("Use " + nameof(Relationship) + " instead.")]
+        public RelationshipAttribute FilteredRelationship { get; set; }
     }
 }