Fixed: sorting on multiple attributes

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -43,6 +43,9 @@ public string FirstName
         [Attr]
         public Gender Gender { get; set; }
 
+        [Attr]
+        public string Category { get; set; }
+
         [HasMany]
         public ISet<TodoItem> TodoItems { get; set; }
 

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -87,11 +87,24 @@ public virtual IQueryable<TResource> Filter(IQueryable<TResource> entities, Filt
         }
 
         /// <inheritdoc />
-        public virtual IQueryable<TResource> Sort(IQueryable<TResource> entities, SortQueryContext sortQueryContext)
+        public virtual IQueryable<TResource> Sort(IQueryable<TResource> entities, IReadOnlyCollection<SortQueryContext> sortQueryContexts)
         {
-            _logger.LogTrace($"Entering {nameof(Sort)}({nameof(entities)}, {nameof(sortQueryContext)}).");
+            _logger.LogTrace($"Entering {nameof(Sort)}({nameof(entities)}, {nameof(sortQueryContexts)}).");
 
-            return entities.Sort(sortQueryContext);
+            if (!sortQueryContexts.Any())
+            {
+                return entities;
+            }
+
+            var primarySort = sortQueryContexts.First();
+            var entitiesSorted = entities.Sort(primarySort);
+
+            foreach (var secondarySort in sortQueryContexts.Skip(1))
+            {
+                entitiesSorted = entitiesSorted.Sort(secondarySort);
+            }
+
+            return entitiesSorted;
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/Data/IResourceReadRepository.cs

@@ -43,7 +43,7 @@ public interface IResourceReadRepository<TResource, in TId>
         /// <summary>
         /// Apply a sort to the provided queryable
         /// </summary>
-        IQueryable<TResource> Sort(IQueryable<TResource> entities, SortQueryContext sortQueries);
+        IQueryable<TResource> Sort(IQueryable<TResource> entities, IReadOnlyCollection<SortQueryContext> sortQueryContexts);
         /// <summary>
         /// Paginate the provided queryable
         /// </summary>

src/JsonApiDotNetCore/Extensions/QueryableExtensions.cs

@@ -77,7 +77,6 @@ public static IOrderedQueryable<TSource> Sort<TSource>(this IQueryable<TSource>
 
         public static IOrderedQueryable<TSource> Sort<TSource>(this IOrderedQueryable<TSource> source, SortQueryContext sortQuery)
         {
-
             return sortQuery.Direction == SortDirection.Descending
                 ? source.ThenByDescending(sortQuery.GetPropertyPath())
                 : source.ThenBy(sortQuery.GetPropertyPath());

src/JsonApiDotNetCore/QueryParameterServices/SortService.cs

@@ -29,13 +29,21 @@ public SortService(IResourceDefinitionProvider resourceDefinitionProvider,
         /// <inheritdoc/>
         public List<SortQueryContext> Get()
         {
-            if (!_queries.Any())
+            if (_queries.Any())
             {
-                var requestResourceDefinition = _resourceDefinitionProvider.Get(_requestResource.ResourceType);
-                if (requestResourceDefinition != null)
-                    return requestResourceDefinition.DefaultSort()?.Select(d => BuildQueryContext(new SortQuery(d.Attribute.PublicAttributeName, d.SortDirection))).ToList();
+                return _queries.ToList();
             }
-            return _queries.ToList();
+
+            var requestResourceDefinition = _resourceDefinitionProvider.Get(_requestResource.ResourceType);
+            var defaultSort = requestResourceDefinition?.DefaultSort();
+            if (defaultSort != null)
+            {
+                return defaultSort
+                    .Select(d => BuildQueryContext(new SortQuery(d.Attribute.PublicAttributeName, d.SortDirection)))
+                    .ToList();
+            }
+
+            return new List<SortQueryContext>();
         }
 
         /// <inheritdoc/>

src/JsonApiDotNetCore/Services/DefaultResourceService.cs

@@ -290,10 +290,7 @@ protected virtual async Task<IEnumerable<TResource>> ApplyPageQueryAsync(IQuerya
         protected virtual IQueryable<TResource> ApplySort(IQueryable<TResource> entities)
         {
             var queries = _sortService.Get();
-            if (queries != null && queries.Any())
-                foreach (var query in queries)
-                    entities = _repository.Sort(entities, query);
-
+            entities = _repository.Sort(entities, queries);
             return entities;
         }
 

test/JsonApiDotNetCoreExampleTests/Acceptance/SerializationTests.cs

@@ -26,7 +26,8 @@ public async Task When_getting_person_it_must_match_JSON_text()
                 FirstName = "John",
                 LastName = "Doe",
                 Age = 57,
-                Gender = Gender.Male
+                Gender = Gender.Male,
+                Category = "Family"
             };
 
             _dbContext.People.RemoveRange(_dbContext.People);
@@ -65,7 +66,8 @@ public async Task When_getting_person_it_must_match_JSON_text()
       ""initials"": ""J"",
       ""lastName"": ""Doe"",
       ""the-Age"": 57,
-      ""gender"": ""Male""
+      ""gender"": ""Male"",
+      ""category"": ""Family""
     },
     ""relationships"": {
       ""todoItems"": {

test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/AttributeSortTests.cs

@@ -1,8 +1,11 @@
+using System;
 using JsonApiDotNetCoreExample;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.JsonApiDocuments;
+using JsonApiDotNetCoreExample.Models;
 using Newtonsoft.Json;
 using Xunit;
 
@@ -40,5 +43,66 @@ public async Task Cannot_Sort_If_Explicitly_Forbidden()
             Assert.Equal("Sorting on attribute 'achievedDate' is not allowed.", errorDocument.Errors[0].Detail);
             Assert.Equal("sort", errorDocument.Errors[0].Source.Parameter);
         }
+
+        [Fact]
+        public async Task Can_Sort_On_Multiple_Attributes()
+        {
+            // Arrange
+            var category = Guid.NewGuid().ToString();
+
+            var persons = new[]
+            {
+                new Person
+                {
+                    Category = category,
+                    FirstName = "Alice",
+                    LastName = "Smith",
+                    Age = 23
+                },
+                new Person
+                {
+                    Category = category,
+                    FirstName = "John",
+                    LastName = "Doe",
+                    Age = 49
+                },
+                new Person
+                {
+                    Category = category,
+                    FirstName = "John",
+                    LastName = "Doe",
+                    Age = 31
+                },
+                new Person
+                {
+                    Category = category,
+                    FirstName = "Jane",
+                    LastName = "Doe",
+                    Age = 19
+                }
+            };
+
+            _fixture.Context.People.AddRange(persons);
+            _fixture.Context.SaveChanges();
+
+            var httpMethod = new HttpMethod("GET");
+            var route = "/api/v1/people?filter[category]=" + category + "&sort=lastName,-firstName,the-Age";
+            var request = new HttpRequestMessage(httpMethod, route);
+
+            // Act
+            var response = await _fixture.Client.SendAsync(request);
+
+            // Assert
+            var body = await response.Content.ReadAsStringAsync();
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+            var document = JsonConvert.DeserializeObject<Document>(body);
+            Assert.Equal(4, document.ManyData.Count);
+
+            Assert.Equal(document.ManyData[0].Id, persons[2].StringId);
+            Assert.Equal(document.ManyData[1].Id, persons[1].StringId);
+            Assert.Equal(document.ManyData[2].Id, persons[3].StringId);
+            Assert.Equal(document.ManyData[3].Id, persons[0].StringId);
+        }
     }
 }