multi group fix.

PoweredSoft.DynamicQuery/QueryHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -53,8 +54,14 @@ namespace PoweredSoft.DynamicQuery
                 sb.ToList("Records");
             });
 
+
             // loop through the grouped records.
             var groupRecords = CurrentQueryable.ToDynamicClassList();
+
+            // now join them into logical collections
+            result.Data = RecursiveRegroup<T>(groupRecords, aggregateResults, Criteria.Groups.First());
+
+/*
             result.Data = groupRecords.Select((groupRecord, groupRecordIndex) =>
             {
                 var groupRecordResult = new GroupQueryResult();
@@ -105,12 +112,73 @@ namespace PoweredSoft.DynamicQuery
                 });
 
                 return (object)groupRecordResult;
-            }).ToList();
+            }).ToList();*/
 
             result.Aggregates = CalculateTotalAggregate<T>(queryableAfterFilters);
             return result;
         }
 
+        protected virtual List<object> RecursiveRegroup<T>(List<DynamicClass> groupRecords, List<List<DynamicClass>> aggregateResults, IGroup group, List<IGroupQueryResult> parentGroupResults = null)
+        {
+            var groupIndex = Criteria.Groups.IndexOf(group);
+            var isLast = Criteria.Groups.Last() == group;
+            var groups = Criteria.Groups.Take(groupIndex + 1).ToList();
+            var hasAggregates = Criteria.Aggregates.Any();
+
+            var ret = groupRecords
+                .GroupBy(gk => gk.GetDynamicPropertyValue($"Key_{groupIndex}"))
+                .Select(t =>
+                {
+                    var groupResult = new GroupQueryResult();
+
+                    // group results.
+
+                    List<IGroupQueryResult> groupResults;
+                    if (parentGroupResults == null)
+                        groupResults = new List<IGroupQueryResult> { groupResult };
+                    else
+                        groupResults = parentGroupResults.Union(new[] { groupResult }).ToList();
+
+                    groupResult.GroupPath = group.Path;
+                    groupResult.GroupValue = t.Key;
+
+                    if (hasAggregates)
+                    {
+                        var matchingAggregate = FindMatchingAggregateResult(aggregateResults, groups, groupResults);
+                        if (matchingAggregate == null)
+                            Debugger.Break();
+
+                        groupResult.Aggregates = new List<IAggregateResult>();
+                        Criteria.Aggregates.ForEach((a, ai) =>
+                        {
+                            var key = $"Agg_{ai}";
+                            var aggregateResult = new AggregateResult
+                            {
+                                Path = a.Path,
+                                Type = a.Type,
+                                Value = matchingAggregate.GetDynamicPropertyValue(key)
+                            };
+                            groupResult.Aggregates.Add(aggregateResult);
+                        });
+                    }
+
+                    if (isLast)
+                    {
+                        var entities = t.SelectMany(t2 => t2.GetDynamicPropertyValue<List<T>>("Records")).ToList();
+                        groupResult.Data = InterceptConvertTo<T>(entities);
+                    }
+                    else
+                    {
+                        groupResult.Data = RecursiveRegroup<T>(t.ToList(), aggregateResults, Criteria.Groups[groupIndex+1], groupResults);
+                    }
+
+                    return groupResult;
+                })
+                .AsEnumerable<object>()
+                .ToList();
+            return ret;
+        }
+
         protected virtual List<IAggregateResult> CalculateTotalAggregate<T>(IQueryable queryableAfterFilters)
         {
             if (!Criteria.Aggregates.Any())
@@ -127,7 +195,7 @@ namespace PoweredSoft.DynamicQuery
                 });
             });
 
-            var aggregateResult = selectExpression.ToDynamicClassList().First();
+            var aggregateResult = selectExpression.ToDynamicClassList().FirstOrDefault();
             var ret = new List<IAggregateResult>();
             Criteria.Aggregates.ForEach((a, index) =>
             {
@@ -135,13 +203,13 @@ namespace PoweredSoft.DynamicQuery
                 {
                     Path = a.Path,
                     Type = a.Type,
-                    Value = aggregateResult.GetDynamicPropertyValue($"Agg_{index}")
+                    Value = aggregateResult?.GetDynamicPropertyValue($"Agg_{index}")
                 });
             });
             return ret;
         }
 
-        private DynamicClass FindMatchingAggregateResult(List<List<DynamicClass>> aggregateResults, List<IGroup> groups, List<GroupQueryResult> groupResults)
+        private DynamicClass FindMatchingAggregateResult(List<List<DynamicClass>> aggregateResults, List<IGroup> groups, List<IGroupQueryResult> groupResults)
         {
             var groupIndex = groupResults.Count - 1;
             var aggregateLevel = aggregateResults[groupIndex];