Extended ILinqReportory to include paging/sorting for IQueryable Find…

…Query methods. Rolled back MediatR due to validation issue.

Src/RCommon.Core/Extensions/IQueryableExtensions.cs

@@ -90,11 +90,11 @@ private static MethodInfo GetLikeMethod(string value, char wildcard)
             return stringType.GetMethod(methodName, new Type[] { stringType });
         }
 
-        public static IPaginatedList<T> ToPaginatedList<T>(this IQueryable<T> source, int? pageIndex, int pageSize)
+        public static IPaginatedList<T> ToPaginatedList<T>(this IQueryable<T> source, int pageNumber = 1, int pageSize = 10)
         {
             Guard.IsNotNegativeOrZero(pageSize, "pageSize");
 
-            return new PaginatedList<T>(source, pageIndex, pageSize);
+            return new PaginatedList<T>(source, pageNumber, pageSize);
         }
 
     }

Src/RCommon.Core/IPagedSpecification.cs

@@ -9,7 +9,7 @@ namespace RCommon
 {
     public interface IPagedSpecification<T> : ISpecification<T>
     {
-        public int PageIndex { get; }
+        public int PageNumber { get; }
         public int PageSize { get; }
 
         public Expression<Func<T, object>> OrderByExpression { get; }

Src/RCommon.Core/PagedSpecification.cs

@@ -10,16 +10,16 @@ namespace RCommon
     public class PagedSpecification<T> : Specification<T>, IPagedSpecification<T>
     {
         public PagedSpecification(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, 
-            bool orderByAscending, int pageIndex, int pageSize) : base(predicate)
+            bool orderByAscending, int pageNumber, int pageSize) : base(predicate)
         {
             OrderByExpression = orderByExpression;
             OrderByAscending = orderByAscending;
-            PageIndex = pageIndex;
+            PageNumber = pageNumber;
             PageSize = pageSize;
         }
 
         public Expression<Func<T, object>> OrderByExpression { get; }
-        public int PageIndex { get;  }
+        public int PageNumber { get;  }
         public int PageSize { get; }
 
         public bool OrderByAscending { get; set; }

Src/RCommon.EfCore/Crud/EFCoreRepository.cs

@@ -202,11 +202,11 @@ public async override Task<IPaginatedList<TEntity>> FindAsync(IPagedSpecificatio
             {
                 query = FindCore(specification.Predicate).OrderByDescending(specification.OrderByExpression);
             }
-            return await Task.FromResult(query.ToPaginatedList(specification.PageIndex, specification.PageSize));
+            return await Task.FromResult(query.ToPaginatedList(specification.PageNumber, specification.PageSize));
         }
 
         public async override Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
-            bool orderByAscending, int? pageIndex, int pageSize = 1,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 1,
             CancellationToken token = default)
         {
             IQueryable<TEntity> query;
@@ -218,7 +218,27 @@ public async override Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TE
             {
                 query = FindCore(expression).OrderByDescending(orderByExpression);
             }
-            return await Task.FromResult(query.ToPaginatedList(pageIndex, pageSize));
+            return await Task.FromResult(query.ToPaginatedList(pageNumber, pageSize));
+        }
+        public override IQueryable<TEntity> FindQuery(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0)
+        {
+            IQueryable<TEntity> query;
+            if (orderByAscending)
+            {
+                query = FindCore(expression).OrderBy(orderByExpression);
+            }
+            else
+            {
+                query = FindCore(expression).OrderByDescending(orderByExpression);
+            }
+            return query.Skip((pageNumber - 1) * pageSize).Take(pageSize);
+        }
+
+        public override IQueryable<TEntity> FindQuery(IPagedSpecification<TEntity> specification)
+        {
+            return this.FindQuery(specification.Predicate, specification.OrderByExpression, 
+                specification.OrderByAscending, specification.PageNumber, specification.PageSize);
         }
 
         public override async Task<TEntity> FindSingleOrDefaultAsync(Expression<Func<TEntity, bool>> expression, CancellationToken token = default)

Src/RCommon.Linq2Db/Crud/Linq2DbRepository.cs

@@ -16,6 +16,7 @@
 using RCommon;
 using RCommon.Persistence.Crud;
 using RCommon.Persistence.Transactions;
+using LinqToDB.Linq;
 
 namespace RCommon.Persistence.Linq2Db.Crud
 {
@@ -184,11 +185,11 @@ public async override Task<IPaginatedList<TEntity>> FindAsync(IPagedSpecificatio
             {
                 query = FindCore(specification.Predicate).OrderByDescending(specification.OrderByExpression);
             }
-            return await Task.FromResult(query.ToPaginatedList(specification.PageIndex, specification.PageSize));
+            return await Task.FromResult(query.ToPaginatedList(specification.PageNumber, specification.PageSize));
         }
 
         public async override Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
-            bool orderByAscending, int? pageIndex, int pageSize = 1,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 1,
             CancellationToken token = default)
         {
             IQueryable<TEntity> query;
@@ -200,7 +201,28 @@ public async override Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TE
             {
                 query = FindCore(expression).OrderByDescending(orderByExpression);
             }
-            return await Task.FromResult(query.ToPaginatedList(pageIndex, pageSize));
+            return await Task.FromResult(query.ToPaginatedList(pageNumber, pageSize));
+        }
+
+        public override IQueryable<TEntity> FindQuery(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression, 
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0)
+        {
+            IQueryable<TEntity> query;
+            if (orderByAscending)
+            {
+                query = FindCore(expression).OrderBy(orderByExpression);
+            }
+            else
+            {
+                query = FindCore(expression).OrderByDescending(orderByExpression);
+            }
+            return query.Skip((pageNumber - 1) * pageSize).Take(pageSize);
+        }
+
+        public override IQueryable<TEntity> FindQuery(IPagedSpecification<TEntity> specification)
+        {
+            return this.FindQuery(specification.Predicate, specification.OrderByExpression,
+                 specification.OrderByAscending, specification.PageNumber, specification.PageSize);
         }
 
         public async override Task<TEntity> FindSingleOrDefaultAsync(Expression<Func<TEntity, bool>> expression, CancellationToken token = default)

Src/RCommon.Mediator/Subscribers/IAppRequest.cs

@@ -11,7 +11,7 @@ public interface IAppRequest
 
     }
 
-    public interface IAppRequest<TResponse>
+    public interface IAppRequest<out TResponse>
     {
 
     }

Src/RCommon.Mediatr/RCommon.MediatR.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MediatR" Version="12.4.0" />
+    <PackageReference Include="MediatR" Version="12.3.0" />
   </ItemGroup>
 
   <ItemGroup>

Src/RCommon.Persistence/Crud/ILinqRepository.cs

@@ -17,9 +17,12 @@ public interface ILinqRepository<TEntity>: IQueryable<TEntity>, IReadOnlyReposit
     {
         IQueryable<TEntity> FindQuery(ISpecification<TEntity> specification);
         IQueryable<TEntity> FindQuery(Expression<Func<TEntity, bool>> expression);
+        IQueryable<TEntity> FindQuery(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0);
+        IQueryable<TEntity> FindQuery(IPagedSpecification<TEntity> specification);
 
         Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
-            bool orderByAscending, int? pageIndex, int pageSize = 0,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0,
             CancellationToken token = default);
         Task<IPaginatedList<TEntity>> FindAsync(IPagedSpecification<TEntity> specification, CancellationToken token = default);
 

Src/RCommon.Persistence/Crud/LinqRepositoryBase.cs

@@ -137,10 +137,14 @@ public IEnumerable<TEntity> Query(ISpecification<TEntity> specification)
         public abstract Task<bool> AnyAsync(ISpecification<TEntity> specification, CancellationToken token = default);
 
         public abstract Task<IPaginatedList<TEntity>> FindAsync(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
-            bool orderByAscending, int? pageIndex, int pageSize = 0,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0,
             CancellationToken token = default);
         public abstract Task<IPaginatedList<TEntity>> FindAsync(IPagedSpecification<TEntity> specification, CancellationToken token = default);
 
+        public abstract IQueryable<TEntity> FindQuery(Expression<Func<TEntity, bool>> expression, Expression<Func<TEntity, object>> orderByExpression,
+            bool orderByAscending, int pageNumber = 1, int pageSize = 0);
+        public abstract IQueryable<TEntity> FindQuery(IPagedSpecification<TEntity> specification);
+
         public abstract IEagerLoadableQueryable<TEntity> Include(Expression<Func<TEntity, object>> path);
 
         public abstract IEagerLoadableQueryable<TEntity> ThenInclude<TPreviousProperty, TProperty>(Expression<Func<object, TProperty>> path);

Tests/RCommon.Persistence.EFCore.Tests/EFCoreRepositoryIntegrationTests.cs

@@ -165,7 +165,7 @@ public async Task Can_Use_Default_Data_Store()
         }
 
         [Test]
-        public async Task Can_Query_Using_Paging_With_Specific_Params()
+        public async Task Can_Find_Using_Paging_With_Specific_Params()
         {
             var repo = new TestRepository(this.ServiceProvider);
             repo.Prepare_Can_query_using_paging_with_specific_params();
@@ -196,7 +196,7 @@ public async Task Can_Query_Using_Paging_With_Specific_Params()
         }
 
         [Test]
-        public async Task Can_Query_Using_Paging_With_Specification()
+        public async Task Can_Find_Using_Paging_With_Specification()
         {
             var repo = new TestRepository(this.ServiceProvider);
             repo.Prepare_Can_query_using_paging_with_specification();
@@ -231,7 +231,7 @@ public async Task Can_Query_Using_Paging_With_Specification()
         }
 
         [Test]
-        public async Task Can_Query_Using_Predicate_Builder()
+        public async Task Can_Find_Using_Predicate_Builder()
         {
             var repo = new TestRepository(this.ServiceProvider);
             repo.Prepare_Can_query_using_predicate_builder();
@@ -249,6 +249,82 @@ public async Task Can_Query_Using_Predicate_Builder()
             Assert.That(customers[4].FirstName == "Homer");
         }
 
+        [Test]
+        public async Task Can_Query_Using_Paging_With_Specific_Params()
+        {
+            var repo = new TestRepository(this.ServiceProvider);
+            repo.Prepare_Can_query_using_paging_with_specific_params();
+
+            var customerRepo = this.ServiceProvider.GetService<IGraphRepository<Customer>>();
+
+            var customers = customerRepo
+                    .FindQuery(x => x.FirstName.StartsWith("Li"), x => x.LastName, true, 1, 10);
+
+            Assert.That(customers != null);
+            Assert.That(customers.Count() == 10);
+            Assert.That(customers.ToList()[4].FirstName == "Lisa");
+
+            customers = customerRepo
+                    .FindQuery(x => x.FirstName.StartsWith("li"), x => x.LastName, true, 2, 10);
+
+            Assert.That(customers != null);
+            Assert.That(customers.Count() == 10);
+            Assert.That(customers.ToList()[4].FirstName == "Lisa");
+
+            repo.CleanUpSeedData();
+        }
+
+        [Test]
+        public async Task Can_Query_Using_Paging_With_Specification()
+        {
+            var repo = new TestRepository(this.ServiceProvider);
+            repo.Prepare_Can_query_using_paging_with_specification();
+
+            var customerRepo = this.ServiceProvider.GetService<IGraphRepository<Customer>>();
+
+            var customerSearchSpec = new CustomerSearchSpec("ba", x => x.FirstName, true, 1, 10);
+
+            var customers = customerRepo
+                    .FindQuery(customerSearchSpec);
+
+            Assert.That(customers != null);
+            Assert.That(customers.Count() == 10);
+            Assert.That(customers.ToList()[4].FirstName == "Bart");
+
+            customerSearchSpec = new CustomerSearchSpec("ba", x => x.FirstName, true, 2, 10);
+
+            customers = customerRepo
+                    .FindQuery(customerSearchSpec);
+
+            Assert.That(customers != null);
+            Assert.That(customers.Count() == 10);
+
+            Assert.That(customers.ToList()[4].FirstName == "Bart");
+
+            repo.CleanUpSeedData();
+        }
+
+        [Test]
+        public async Task Can_Query_Using_Predicate_Builder()
+        {
+            var repo = new TestRepository(this.ServiceProvider);
+            repo.Prepare_Can_query_using_predicate_builder();
+
+            var customerRepo = this.ServiceProvider.GetService<IGraphRepository<Customer>>();
+
+            var predicate = PredicateBuilder.True<Customer>(); // This allows us to build compound expressions
+            predicate.And(x => x.FirstName.StartsWith("Ho"));
+
+            var customers = customerRepo
+                    .FindQuery(predicate, x => x.LastName, true, 1, 10);
+
+            Assert.That(customers != null);
+            Assert.That(customers.Count() == 10);
+            Assert.That(customers.ToList()[4].FirstName == "Homer");
+
+            repo.CleanUpSeedData();
+        }
+
 
 
         [Test]