Merge branch 'release/2.x-ready'

David Lebee · David Lebee · commit 17e9434722a7 · 2019-03-22T16:18:24.000-05:00
diff --git a/PoweredSoft.DynamicQuery.AspNetCore/PoweredSoft.DynamicQuery.AspNetCore.csproj b/PoweredSoft.DynamicQuery.AspNetCore/PoweredSoft.DynamicQuery.AspNetCore.csproj
@@ -8,7 +8,7 @@
     <RepositoryUrl>https://github.com/PoweredSoft/DynamicQuery</RepositoryUrl>
     <RepositoryType>github</RepositoryType>
     <PackageTags>powered,soft,dynamic,criteria,query,builder,asp,net,core</PackageTags>
-    <Version>1.0.0$(VersionSuffix)</Version>
+    <Version>2.0.0$(VersionSuffix)</Version>
     <PackageIconUrl>https://secure.gravatar.com/avatar/4e32f73820c16718909a06c2927f1f8b?s=512&amp;amp;r=g&amp;amp;d=retro</PackageIconUrl>
     <Product>PoweredSoft.DynamicQuery.AspNetCore</Product>
     <Description>This projects makes it easier to use dynamic query in a asp.net core mvc project.</Description>
diff --git a/PoweredSoft.DynamicQuery.Core/IAfterReadInterceptor.cs b/PoweredSoft.DynamicQuery.Core/IAfterReadInterceptor.cs
@@ -24,4 +24,14 @@ public interface IAfterReadInterceptorAsync<T> : IQueryInterceptor
     {
         Task AfterReadAsync(List<Tuple<T, object>> pairs, CancellationToken cancellationToken = default(CancellationToken));
     }
+
+    public interface IAfterReadInterceptor<T, T2> : IQueryInterceptor
+    {
+        void AfterRead(List<Tuple<T, T2>> pairs);
+    }
+
+    public interface IAfterReadInterceptorAsync<T, T2> : IQueryInterceptor
+    {
+        Task AfterReadAsync(List<Tuple<T, T2>> pairs, CancellationToken cancellationToken = default(CancellationToken));
+    }
 }
diff --git a/PoweredSoft.DynamicQuery.Core/IQueryConvertInterceptor.cs b/PoweredSoft.DynamicQuery.Core/IQueryConvertInterceptor.cs
@@ -13,4 +13,9 @@ public interface IQueryConvertInterceptor<T> : IQueryInterceptor
     {
         object InterceptResultTo(T entity);
     }
+
+    public interface IQueryConvertInterceptor<T, T2> : IQueryInterceptor
+    {
+        T2 InterceptResultTo(T entity);
+    }
 }
diff --git a/PoweredSoft.DynamicQuery.Core/IQueryHandler.cs b/PoweredSoft.DynamicQuery.Core/IQueryHandler.cs
@@ -13,11 +13,13 @@ public interface IInterceptableQueryHandler
 
     public interface IQueryHandler : IInterceptableQueryHandler
     {
-        IQueryExecutionResult Execute(IQueryable queryable, IQueryCriteria criteria);
+        IQueryExecutionResult<TSource> Execute<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria);
+        IQueryExecutionResult<TRecord> Execute<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria);
     }
 
     public interface IQueryHandlerAsync : IInterceptableQueryHandler
     {
-        Task<IQueryExecutionResult> ExecuteAsync(IQueryable queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));
+        Task<IQueryExecutionResult<TSource>> ExecuteAsync<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));
+        Task<IQueryExecutionResult<TRecord>> ExecuteAsync<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));
     }
 }
diff --git a/PoweredSoft.DynamicQuery.Core/IQueryResult.cs b/PoweredSoft.DynamicQuery.Core/IQueryResult.cs
@@ -11,23 +11,35 @@ public interface IAggregateResult
         object Value { get; set; }
     }
 
-    public interface IQueryResult
+    public interface IQueryResult<TRecord>
     {
         List<IAggregateResult> Aggregates { get; }
-        List<object> Data { get; }
+        List<TRecord> Data { get; }
     }
 
-    public interface IGroupQueryResult : IQueryResult
+    public interface IGroupQueryResult<TRecord> : IQueryResult<TRecord>
     {
         string GroupPath { get; set; }
         object GroupValue { get; set; }
+        bool HasSubGroups { get; }
+        List<IGroupQueryResult<TRecord>> SubGroups { get; set; }
     }
 
-    public interface IQueryExecutionResult : IQueryResult
+    public interface IQueryExecutionResultPaging
     {
         long TotalRecords { get; set; }
         long? NumberOfPages { get; set; }
     }
 
-   
+    public interface IQueryExecutionResult<TRecord> : IQueryResult<TRecord>, IQueryExecutionResultPaging
+    {
+
+    }
+
+    public interface IQueryExecutionGroupResult<TRecord> : IQueryExecutionResult<TRecord>
+    {
+        List<IGroupQueryResult<TRecord>> Groups { get; set; }
+    }
+
+
 }
diff --git a/PoweredSoft.DynamicQuery.Core/PoweredSoft.DynamicQuery.Core.csproj b/PoweredSoft.DynamicQuery.Core/PoweredSoft.DynamicQuery.Core.csproj
@@ -8,7 +8,7 @@
     <RepositoryUrl>https://github.com/PoweredSoft/DynamicQuery.Core/</RepositoryUrl>
     <RepositoryType>github</RepositoryType>
     <PackageTags>powered,soft,dynamic,criteria,query,builder</PackageTags>
-    <Version>1.0.0$(VersionSuffix)</Version>
+    <Version>2.0.0$(VersionSuffix)</Version>
     <PackageIconUrl>https://secure.gravatar.com/avatar/4e32f73820c16718909a06c2927f1f8b?s=512&amp;amp;r=g&amp;amp;d=retro</PackageIconUrl>
     <Product>PoweredSoft.DynamicQuery.Core</Product>
     <Description>core abstractions</Description>
diff --git a/PoweredSoft.DynamicQuery.Test/AggregateTests.cs b/PoweredSoft.DynamicQuery.Test/AggregateTests.cs
@@ -114,7 +114,11 @@ public void WithGrouping()
 
                 var queryHandler = new QueryHandler();
                 var result = queryHandler.Execute(ctx.OrderItems, criteria);
-                var groups = result.Data.Cast<IGroupQueryResult>().ToList();
+
+                var groupedResult = result as IQueryExecutionGroupResult<OrderItem>;
+                Assert.NotNull(groupedResult);
+
+                var groups = groupedResult.Groups;
 
                 // validate group and aggregates of groups.
                 Assert.Equal(groups.Count, shouldResults.Count);
diff --git a/PoweredSoft.DynamicQuery.Test/AsyncTests.cs b/PoweredSoft.DynamicQuery.Test/AsyncTests.cs
@@ -1,6 +1,7 @@
 ﻿using PoweredSoft.Data;
 using PoweredSoft.Data.EntityFrameworkCore;
 using PoweredSoft.DynamicQuery.Core;
+using PoweredSoft.DynamicQuery.Extensions;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
 using System.Collections.Generic;
@@ -65,7 +66,7 @@ public void WithGrouping()
                 var asyncService = new AsyncQueryableService(new[] { new AsyncQueryableHandlerService() });
                 var queryHandler = new QueryHandlerAsync(asyncService);
                 var result = await queryHandler.ExecuteAsync(ctx.OrderItems, criteria);
-                var groups = result.Data.Cast<IGroupQueryResult>().ToList();
+                var groups = result.GroupedResult().Groups;
 
                 // validate group and aggregates of groups.
                 Assert.Equal(groups.Count, shouldResults.Count);
diff --git a/PoweredSoft.DynamicQuery.Test/ConvertibleInterceptorTests.cs b/PoweredSoft.DynamicQuery.Test/ConvertibleInterceptorTests.cs
@@ -55,6 +55,22 @@ public object InterceptResultTo(Order entity)
             }
         }
 
+        private class MockQueryConvertGenericInterceptor2 :
+            IQueryConvertInterceptor<Customer, CustomerModel>
+        {
+            public CustomerModel InterceptResultTo(Customer entity)
+            {
+                var customer = entity;
+                var personModel = new CustomerModel
+                {
+                    Id = customer.Id,
+                    FirstName = customer.FirstName,
+                    LastName = customer.LastName
+                };
+                return personModel;
+            }
+        }
+
         [Fact]
         public void NonGeneric()
         {
@@ -63,7 +79,7 @@ public void NonGeneric()
                 var criteria = new QueryCriteria();
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(new MockQueryConvertInterceptor());
-                var result = queryHandler.Execute(ctx.Customers, criteria);
+                var result = queryHandler.Execute<Customer, CustomerModel>(ctx.Customers, criteria);
                 Assert.All(result.Data, t => Assert.IsType<CustomerModel>(t));
             });
         }
@@ -76,7 +92,20 @@ public void Generic()
                 var criteria = new QueryCriteria();
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(new MockQueryConvertGenericInterceptor());
-                var result = queryHandler.Execute(ctx.Customers, criteria);
+                var result = queryHandler.Execute<Customer, CustomerModel>(ctx.Customers, criteria);
+                Assert.All(result.Data, t => Assert.IsType<CustomerModel>(t));
+            });
+        }
+
+        [Fact]
+        public void Generic2()
+        {
+            MockContextFactory.SeedAndTestContextFor("ConvertibleIntereceptorTests_Generic2", TestSeeders.SimpleSeedScenario, ctx =>
+            {
+                var criteria = new QueryCriteria();
+                var queryHandler = new QueryHandler();
+                queryHandler.AddInterceptor(new MockQueryConvertGenericInterceptor2());
+                var result = queryHandler.Execute<Customer, CustomerModel>(ctx.Customers, criteria);
                 Assert.All(result.Data, t => Assert.IsType<CustomerModel>(t));
             });
         }
diff --git a/PoweredSoft.DynamicQuery.Test/GroupInterceptorTests.cs b/PoweredSoft.DynamicQuery.Test/GroupInterceptorTests.cs
@@ -1,4 +1,5 @@
 ﻿using PoweredSoft.DynamicQuery.Core;
+using PoweredSoft.DynamicQuery.Extensions;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
 using System.Collections.Generic;
@@ -37,7 +38,9 @@ public void Simple()
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(new MockGroupInterceptor());
                 var result = queryHandler.Execute(ctx.Orders, criteria);
-                var actual = result.Data.Cast<IGroupQueryResult>().Select(t => t.GroupValue).ToList();
+
+                var groupedResult = result.GroupedResult();
+                var actual = groupedResult.Groups.Select(t => t.GroupValue).ToList();
                 Assert.Equal(expected, actual);
             });
         }
diff --git a/PoweredSoft.DynamicQuery.Test/GroupTests.cs b/PoweredSoft.DynamicQuery.Test/GroupTests.cs
@@ -1,4 +1,5 @@
 ﻿using PoweredSoft.DynamicQuery.Core;
+using PoweredSoft.DynamicQuery.Extensions;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
 using System.Collections.Generic;
@@ -34,13 +35,14 @@ public void Simple()
 
                 var queryHandler = new QueryHandler();
                 var result = queryHandler.Execute(ctx.Orders, criteria);
+                var groupedResult = result.GroupedResult();
 
                 // top level should have same amount of group levels.
-                Assert.Equal(result.Data.Count, shouldResult.Count);
+                Assert.Equal(groupedResult.Groups.Count, shouldResult.Count);
                 for (var i = 0; i < shouldResult.Count; i++)
                 {
                     var expected = shouldResult[0];
-                    var actual = ((IGroupQueryResult)result.Data[0]);
+                    var actual = groupedResult.Groups[0];
                     Assert.Equal(expected.Customer.Id, (actual.GroupValue as Customer).Id);
 
                     var expectedOrderIds = expected.Orders.Select(t => t.Id).ToList();
@@ -71,13 +73,15 @@ public void GroupComplex()
                 var queryHandler = new QueryHandler();
                 var result = queryHandler.Execute(ctx.Tickets, criteria);
 
-                var firstGroup = result.Data[0] as IGroupQueryResult;
+                var groupedResult = result.GroupedResult();
+
+                var firstGroup = groupedResult.Groups.FirstOrDefault();
                 Assert.NotNull(firstGroup);
-                var secondGroup = result.Data[1] as IGroupQueryResult;
+                var secondGroup = groupedResult.Groups.Skip(1).FirstOrDefault();
                 Assert.NotNull(secondGroup);
 
                 var expected = ctx.Tickets.Select(t => t.TicketType).Distinct().Count();
-                var c = result.Data.Cast<IGroupQueryResult>().Select(t => t.GroupValue).Count();
+                var c = groupedResult.Groups.Select(t => t.GroupValue).Count();
                 Assert.Equal(expected, c);
             });
         }
@@ -102,7 +106,7 @@ public void InterceptorsWithGrouping()
                 var interceptor = new InterceptorsWithGrouping();
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(interceptor);
-                var result = queryHandler.Execute(ctx.Tickets, criteria);
+                var result = queryHandler.Execute<Ticket, InterceptorWithGroupingFakeModel>(ctx.Tickets, criteria);
                 Assert.Equal(4, interceptor.Count);
                 Assert.True(interceptor.Test);
                 Assert.True(interceptor.Test2);
diff --git a/PoweredSoft.DynamicQuery/Extensions/GroupResultExtensions.cs b/PoweredSoft.DynamicQuery/Extensions/GroupResultExtensions.cs
@@ -0,0 +1,18 @@
+﻿using PoweredSoft.DynamicQuery.Core;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace PoweredSoft.DynamicQuery.Extensions
+{
+    public static class GroupResultExtensions
+    {
+        public static IQueryExecutionGroupResult<TRecord> GroupedResult<TRecord>(this IQueryExecutionResult<TRecord> source)
+        {
+            if (source is IQueryExecutionGroupResult<TRecord> ret)
+                return ret;
+
+            throw new Exception("this result is not a grouped result");                
+        }
+    }
+}
diff --git a/PoweredSoft.DynamicQuery/PoweredSoft.DynamicQuery.csproj b/PoweredSoft.DynamicQuery/PoweredSoft.DynamicQuery.csproj
@@ -8,7 +8,7 @@
     <RepositoryUrl>https://github.com/PoweredSoft/DynamicQuery</RepositoryUrl>
     <RepositoryType>github</RepositoryType>
     <PackageTags>powered,soft,dynamic,criteria,query,builder</PackageTags>
-    <Version>1.0.0$(VersionSuffix)</Version>
+    <Version>2.0.0$(VersionSuffix)</Version>
     <PackageIconUrl>https://secure.gravatar.com/avatar/4e32f73820c16718909a06c2927f1f8b?s=512&amp;amp;r=g&amp;amp;d=retro</PackageIconUrl>
     <Product>PoweredSoft.DynamicQuery</Product>
     <Description>dynamic query based on string path very usefull for network requests.</Description>
diff --git a/PoweredSoft.DynamicQuery/QueryHandler.cs b/PoweredSoft.DynamicQuery/QueryHandler.cs
diff --git a/PoweredSoft.DynamicQuery/QueryHandlerAsync.cs b/PoweredSoft.DynamicQuery/QueryHandlerAsync.cs
diff --git a/PoweredSoft.DynamicQuery/QueryHandlerBase.cs b/PoweredSoft.DynamicQuery/QueryHandlerBase.cs
diff --git a/PoweredSoft.DynamicQuery/QueryResult.cs b/PoweredSoft.DynamicQuery/QueryResult.cs
diff --git a/README.md b/README.md

Original file line number	Diff line number	Diff line change
`@@ -24,4 +24,14 @@ public interface IAfterReadInterceptorAsync<T> : IQueryInterceptor`
`24`	`24`	`{`
`25`	`25`	`Task AfterReadAsync(List<Tuple<T, object>> pairs, CancellationToken cancellationToken = default(CancellationToken));`
`26`	`26`	`}`
	`27`	`+`
	`28`	`+ public interface IAfterReadInterceptor<T, T2> : IQueryInterceptor`
	`29`	`+ {`
	`30`	`+ void AfterRead(List<Tuple<T, T2>> pairs);`
	`31`	`+ }`
	`32`	`+`
	`33`	`+ public interface IAfterReadInterceptorAsync<T, T2> : IQueryInterceptor`
	`34`	`+ {`
	`35`	`+ Task AfterReadAsync(List<Tuple<T, T2>> pairs, CancellationToken cancellationToken = default(CancellationToken));`
	`36`	`+ }`
`27`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,4 +13,9 @@ public interface IQueryConvertInterceptor<T> : IQueryInterceptor`
`13`	`13`	`{`
`14`	`14`	`object InterceptResultTo(T entity);`
`15`	`15`	`}`
	`16`	`+`
	`17`	`+ public interface IQueryConvertInterceptor<T, T2> : IQueryInterceptor`
	`18`	`+ {`
	`19`	`+ T2 InterceptResultTo(T entity);`
	`20`	`+ }`
`16`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,13 @@ public interface IInterceptableQueryHandler`
`13`	`13`
`14`	`14`	`public interface IQueryHandler : IInterceptableQueryHandler`
`15`	`15`	`{`
`16`		`- IQueryExecutionResult Execute(IQueryable queryable, IQueryCriteria criteria);`
	`16`	`+ IQueryExecutionResult<TSource> Execute<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria);`
	`17`	`+ IQueryExecutionResult<TRecord> Execute<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria);`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`public interface IQueryHandlerAsync : IInterceptableQueryHandler`
`20`	`21`	`{`
`21`		`- Task<IQueryExecutionResult> ExecuteAsync(IQueryable queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));`
	`22`	`+ Task<IQueryExecutionResult<TSource>> ExecuteAsync<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));`
	`23`	`+ Task<IQueryExecutionResult<TRecord>> ExecuteAsync<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));`
`22`	`24`	`}`
`23`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,23 +11,35 @@ public interface IAggregateResult`
`11`	`11`	`object Value { get; set; }`
`12`	`12`	`}`
`13`	`13`
`14`		`- public interface IQueryResult`
	`14`	`+ public interface IQueryResult<TRecord>`
`15`	`15`	`{`
`16`	`16`	`List<IAggregateResult> Aggregates { get; }`
`17`		`- List<object> Data { get; }`
	`17`	`+ List<TRecord> Data { get; }`
`18`	`18`	`}`
`19`	`19`
`20`		`- public interface IGroupQueryResult : IQueryResult`
	`20`	`+ public interface IGroupQueryResult<TRecord> : IQueryResult<TRecord>`
`21`	`21`	`{`
`22`	`22`	`string GroupPath { get; set; }`
`23`	`23`	`object GroupValue { get; set; }`
	`24`	`+ bool HasSubGroups { get; }`
	`25`	`+ List<IGroupQueryResult<TRecord>> SubGroups { get; set; }`
`24`	`26`	`}`
`25`	`27`
`26`		`- public interface IQueryExecutionResult : IQueryResult`
	`28`	`+ public interface IQueryExecutionResultPaging`
`27`	`29`	`{`
`28`	`30`	`long TotalRecords { get; set; }`
`29`	`31`	`long? NumberOfPages { get; set; }`
`30`	`32`	`}`
`31`	`33`
`32`		`-`
	`34`	`+ public interface IQueryExecutionResult<TRecord> : IQueryResult<TRecord>, IQueryExecutionResultPaging`
	`35`	`+ {`
	`36`	`+`
	`37`	`+ }`
	`38`	`+`
	`39`	`+ public interface IQueryExecutionGroupResult<TRecord> : IQueryExecutionResult<TRecord>`
	`40`	`+ {`
	`41`	`+ List<IGroupQueryResult<TRecord>> Groups { get; set; }`
	`42`	`+ }`
	`43`	`+`
	`44`	`+`
`33`	`45`	`}`