grouping is starting well :P

PoweredSoft.DynamicQuery/Aggregate.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using PoweredSoft.DynamicQuery.Core;
+
+namespace PoweredSoft.DynamicQuery
+{
+    public class Aggregate : IAggregate
+    {
+        public string Path { get; set; }
+        public AggregateType Type { get; set; }
+    }
+}

PoweredSoft.DynamicQuery/Extensions/FilterTypeExtensions.cs

@@ -35,5 +35,19 @@ namespace PoweredSoft.DynamicQuery.Extensions
 
             return null;
         }
+
+        public static SelectTypes? SelectType(this AggregateType aggregateType)
+        {
+            if (aggregateType == AggregateType.Avg)
+                return SelectTypes.Average;
+            if (aggregateType == AggregateType.Count)
+                return SelectTypes.Count;
+            if (aggregateType == AggregateType.LongCount)
+                return SelectTypes.LongCount;
+            if (aggregateType == AggregateType.Sum)
+                return SelectTypes.Sum;
+
+            return null;
+        }
     }
 }

PoweredSoft.DynamicQuery/QueryHandler.cs

@@ -23,9 +23,35 @@ namespace PoweredSoft.DynamicQuery
 
         protected virtual IQueryExecutionResult ExecuteGrouping<T>()
         {
-            throw new NotImplementedException();
+            var result = new GroupedQueryExecutionResult();
+            result.TotalRecords = CurrentQueryable.LongCount();
+
+            Criteria.Groups.ForEach(group =>
+            {
+                var finalGroup = InterceptGroup<T>(group);
+                var groupCleanedPath = group.Path.Replace(".", "");
+                CurrentQueryable = CurrentQueryable.GroupBy(QueryableUnderlyingType, gb =>
+                {
+                    gb.Path(finalGroup.Path);
+                });
+
+                CurrentQueryable = CurrentQueryable.Select(sb =>
+                {
+                    sb.ToList("Data");
+                    sb.Key($"Group_{groupCleanedPath}", group.Path);
+                    Criteria.Aggregates.ForEach(a =>
+                    {
+                        var selectType = ResolveSelectFrom(a.Type);
+                        var pathCleaned = a.Path.Replace(".", "");
+                        sb.Aggregate(a.Path, selectType, $"Agg_{a.Type}_{pathCleaned}");
+                    });
+                });
+            });
+
+            return result;
         }
 
+
         protected virtual IQueryExecutionResult ExecuteNoGrouping<T>()
         {
             var result = new QueryExecutionResult();

PoweredSoft.DynamicQuery/QueryHandlerBase.cs

@@ -38,6 +38,17 @@ namespace PoweredSoft.DynamicQuery
                 Interceptors.Add(interceptor);
         }
 
+        protected virtual IGroup InterceptGroup<T>(IGroup group)
+        {
+            var ret = Interceptors
+                .Where(t => t is IGroupingInterceptor)
+                .Cast<IGroupingInterceptor>()
+                .Aggregate(group, (prev, inter) => inter.InterceptGroup(prev));
+
+            return ret;
+        }
+
+
         protected virtual void ApplyNoGroupingPaging<T>()
         {
             if (!HasPaging)
@@ -66,12 +77,18 @@ namespace PoweredSoft.DynamicQuery
 
         protected virtual List<ISort> InterceptSort<T>(ISort sort)
         {
+            var original = new List<ISort>()
+            {
+                sort
+            };
+
             var ret = Interceptors
                 .Where(t => t is ISortInterceptor)
                 .Cast<ISortInterceptor>()
-                .SelectMany(interceptor => interceptor.InterceptSort(sort));
+                .Aggregate(original as IEnumerable<ISort>, (prev, inter) => inter.InterceptSort(prev))
+                .Distinct();
 
-            return ret.Distinct().ToList();
+            return ret.ToList();
         }
 
         protected virtual void ApplyNoSortInterceptor<T>()
@@ -85,17 +102,28 @@ namespace PoweredSoft.DynamicQuery
                 .Aggregate((IQueryable<T>)CurrentQueryable, (prev, interceptor) => interceptor.InterceptNoSort(prev));
         }
 
-        protected virtual ConditionOperators? ResolveFromOrDefault(FilterType filterType) => filterType.ConditionOperator();
 
-        protected virtual ConditionOperators ResolveFrom(FilterType filterType)
+        protected virtual SelectTypes? ResolveSelectFromOrDefault(AggregateType aggregateType) => aggregateType.SelectType();
+        protected virtual ConditionOperators? ResolveConditionOperatorFromOrDefault(FilterType filterType) => filterType.ConditionOperator();
+
+        protected virtual ConditionOperators ResolveConditionOperatorFrom(FilterType filterType)
         {
-            var ret = ResolveFromOrDefault(filterType);
+            var ret = ResolveConditionOperatorFromOrDefault(filterType);
             if (ret == null)
                 throw new NotSupportedException($"{filterType} is not supported");
 
             return ret.Value;
         }
 
+        protected virtual SelectTypes ResolveSelectFrom(AggregateType aggregateType)
+        {
+            var ret = ResolveSelectFromOrDefault(aggregateType);
+            if (ret == null)
+                throw new NotSupportedException($"{aggregateType} is not supported");
+
+            return ret.Value;
+        }
+
         protected virtual void ApplyFilters<T>()
         {
             if (true != Criteria.Filters?.Any())
@@ -125,7 +153,7 @@ namespace PoweredSoft.DynamicQuery
 
         protected virtual void ApplySimpleFilter<T>(WhereBuilder whereBuilder, ISimpleFilter filter)
         {
-            var resolvedConditionOperator = ResolveFrom(filter.Type);
+            var resolvedConditionOperator = ResolveConditionOperatorFrom(filter.Type);
             whereBuilder.Compare(filter.Path, resolvedConditionOperator, filter.Value, and: filter.And == true);
         }