Merge pull request #28 from nodes-dotnet/feature/26-select-statement

Feature/26 select statement

Author: Morten Turn Pedersen

NetCoreEntityFramework.Tests/EntityRepositoryTests.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using TestContext = Nodes.NetCore.EntityFramework.Tests.Mocks.TestContext;
 
@@ -93,7 +94,6 @@ public void AddThrowsExceptionIfEntityIsNull()
         #endregion
 
         #region List
-
         [Test]
         public async Task GetListReturnsAll()
         {
@@ -167,6 +167,80 @@ public async Task GetListPaginated()
             Assert.AreEqual(3, entitiesLastPage.Count());
         }
 
+        [Test]
+        public async Task GetListWithSelectReturnsAll()
+        {
+            var entities = await _repository.GetListWithSelect<string>(e => e.Property);
+
+            Assert.AreEqual(_listEntities.Count() + 1, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListWithSelectWhere()
+        {
+            const string propertyToLookFor = "b";
+            IEnumerable<string> entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property == propertyToLookFor);
+
+            Assert.AreEqual(1, entities.Count());
+            Assert.AreEqual(propertyToLookFor, entities.ElementAt(0));
+        }
+
+        [Test]
+        public async Task GetListWithSelectOrderBy()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property.Length == 1, x => x.Property);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreEqual("a", entities.ElementAt(0));
+            Assert.AreEqual("b", entities.ElementAt(1));
+            Assert.AreEqual("c", entities.ElementAt(2));
+            Assert.AreEqual("d", entities.ElementAt(3));
+            Assert.AreEqual("e", entities.ElementAt(4));
+            Assert.AreEqual("f", entities.ElementAt(5));
+            Assert.AreEqual("g", entities.ElementAt(6));
+            Assert.AreEqual("h", entities.ElementAt(7));
+            Assert.AreEqual("i", entities.ElementAt(8));
+            Assert.AreEqual("j", entities.ElementAt(9));
+            Assert.AreEqual("k", entities.ElementAt(10));
+            Assert.AreEqual("l", entities.ElementAt(11));
+            Assert.AreEqual("m", entities.ElementAt(12));
+            Assert.AreEqual("n", entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListWithSelectOrderByDescending()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property.Length == 1, x => x.Property, OrderBy.Descending);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreEqual("n", entities.ElementAt(0));
+            Assert.AreEqual("m", entities.ElementAt(1));
+            Assert.AreEqual("l", entities.ElementAt(2));
+            Assert.AreEqual("k", entities.ElementAt(3));
+            Assert.AreEqual("j", entities.ElementAt(4));
+            Assert.AreEqual("i", entities.ElementAt(5));
+            Assert.AreEqual("h", entities.ElementAt(6));
+            Assert.AreEqual("g", entities.ElementAt(7));
+            Assert.AreEqual("f", entities.ElementAt(8));
+            Assert.AreEqual("e", entities.ElementAt(9));
+            Assert.AreEqual("d", entities.ElementAt(10));
+            Assert.AreEqual("c", entities.ElementAt(11));
+            Assert.AreEqual("b", entities.ElementAt(12));
+            Assert.AreEqual("a", entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListWithSelectPaginated()
+        {
+            const int pageSize = 6;
+
+            var entities = await _repository.GetListWithSelect(x => x.Property, 1, pageSize);
+            var entitiesLastPage = await _repository.GetListWithSelect(x => x.Property, 3, pageSize);
+
+            Assert.AreEqual(pageSize, entities.Count());
+            Assert.AreEqual(3, entitiesLastPage.Count());
+        }
+
         private IEnumerable<TestEntity> GetTestList()
         {
             return new List<TestEntity>

NetCoreEntityFramework.Tests/EntitySoftDeleteRepositoryTests.cs

@@ -227,6 +227,94 @@ private TestSoftDeleteEntity GetTestEntity(string property)
                 Property = property
             };
         }
+        [Test]
+        public async Task GetListWithReturnsReturnsAllNotDeleted()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property);
+
+            Assert.AreEqual(_listEntities.Count() + 1, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListWithSelectReturnsAll()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, null, null, OrderBy.Ascending, GetListMode.IncludeDeleted);
+
+            Assert.AreEqual(_listEntities.Count() + 2, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListWithSelectReturnsAllDeleted()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, null, null, OrderBy.Ascending, GetListMode.OnlyDeleted);
+
+            Assert.AreEqual(1, entities.Count());
+        }
+
+        [Test]
+        public async Task GetListWithSelectWhere()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property == "b");
+
+            Assert.AreEqual(1, entities.Count());
+            Assert.AreEqual("b", entities.ElementAt(0));
+        }
+
+        [Test]
+        public async Task GetListWithSelectOrderBy()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property.Length == 1, x => x.Property);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreEqual("a", entities.ElementAt(0));
+            Assert.AreEqual("b", entities.ElementAt(1));
+            Assert.AreEqual("c", entities.ElementAt(2));
+            Assert.AreEqual("d", entities.ElementAt(3));
+            Assert.AreEqual("e", entities.ElementAt(4));
+            Assert.AreEqual("f", entities.ElementAt(5));
+            Assert.AreEqual("g", entities.ElementAt(6));
+            Assert.AreEqual("h", entities.ElementAt(7));
+            Assert.AreEqual("i", entities.ElementAt(8));
+            Assert.AreEqual("j", entities.ElementAt(9));
+            Assert.AreEqual("k", entities.ElementAt(10));
+            Assert.AreEqual("l", entities.ElementAt(11));
+            Assert.AreEqual("m", entities.ElementAt(12));
+            Assert.AreEqual("n", entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListWithSelectOrderByDescending()
+        {
+            var entities = await _repository.GetListWithSelect(x => x.Property, x => x.Property.Length == 1, x => x.Property, OrderBy.Descending);
+
+            Assert.AreEqual(_listEntities.Count(), entities.Count());
+            Assert.AreEqual("n", entities.ElementAt(0));
+            Assert.AreEqual("m", entities.ElementAt(1));
+            Assert.AreEqual("l", entities.ElementAt(2));
+            Assert.AreEqual("k", entities.ElementAt(3));
+            Assert.AreEqual("j", entities.ElementAt(4));
+            Assert.AreEqual("i", entities.ElementAt(5));
+            Assert.AreEqual("h", entities.ElementAt(6));
+            Assert.AreEqual("g", entities.ElementAt(7));
+            Assert.AreEqual("f", entities.ElementAt(8));
+            Assert.AreEqual("e", entities.ElementAt(9));
+            Assert.AreEqual("d", entities.ElementAt(10));
+            Assert.AreEqual("c", entities.ElementAt(11));
+            Assert.AreEqual("b", entities.ElementAt(12));
+            Assert.AreEqual("a", entities.ElementAt(13));
+        }
+
+        [Test]
+        public async Task GetListWithSelectPaginated()
+        {
+            const int pageSize = 6;
+
+            var entities = await _repository.GetListWithSelect(x => x.Property, 1, pageSize);
+            var entitiesLastPage = await _repository.GetListWithSelect(x => x.Property, 3, pageSize);
+
+            Assert.AreEqual(pageSize, entities.Count());
+            Assert.AreEqual(3, entitiesLastPage.Count());
+        }
         #endregion
 
         #region Get

NetCoreEntityFramework/Repositories/EntityRepository.cs

@@ -37,6 +37,21 @@ public async virtual Task<IEnumerable<TEntity>> GetList(
             return await query.ToListAsync();
         }
 
+        public async virtual Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            [Range(1, int.MaxValue)] int page,
+            [Range(1, int.MaxValue)] int pageSize,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending)
+        {
+            IQueryable<TEntity> query = GetQueryable(where, orderByExpression, orderBy);
+
+            query = Paginate(query, page, pageSize);
+
+            return await query.Select(select).ToListAsync();
+        }
+
         public async virtual Task<IEnumerable<TEntity>> GetList(
             Expression<Func<TEntity, bool>> where = null,
             Expression<Func<TEntity, object>> orderByExpression = null,
@@ -47,6 +62,17 @@ public async virtual Task<IEnumerable<TEntity>> GetList(
             return await query.ToListAsync();
         }
 
+        public async virtual Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending)
+        {
+            IQueryable<TEntity> query = GetQueryable(where, orderByExpression, orderBy);
+
+            return await query.Select(select).ToListAsync();
+        }
+
         public virtual Task Add(TEntity entity)
         {
             if (entity == null)

NetCoreEntityFramework/Repositories/EntitySoftDeleteRepository.cs

@@ -44,6 +44,32 @@ public async virtual Task<IEnumerable<TEntity>> GetList(
             return await query.ToListAsync();
         }
 
+        public virtual async Task<IEnumerable<TResult>> GetListWithSelect<TResult>(Expression<Func<TEntity, TResult>> select,
+                                                                     [Range(1, int.MaxValue)] int page,
+                                                                     [Range(1, int.MaxValue)] int pageSize,
+                                                                     Expression<Func<TEntity, bool>> where = null,
+                                                                     Expression<Func<TEntity, object>> orderByExpression = null,
+                                                                     OrderBy orderBy = OrderBy.Ascending,
+                                                                     GetListMode mode = GetListMode.ExcludeDeleted)
+        {
+            IQueryable<TEntity> query = GetQueryable(where, orderByExpression, orderBy, mode);
+
+            query = Paginate(query, page, pageSize);
+
+            return await query.Select(select).ToListAsync();
+        }
+
+        public async virtual Task<IEnumerable<TResult>> GetListWithSelect<TResult>(Expression<Func<TEntity, TResult>> select,
+                                                                     Expression<Func<TEntity, bool>> where = null,
+                                                                     Expression<Func<TEntity, object>> orderByExpression = null,
+                                                                     OrderBy orderBy = OrderBy.Ascending,
+                                                                     GetListMode mode = GetListMode.ExcludeDeleted)
+        {
+            IQueryable<TEntity> query = GetQueryable(where, orderByExpression, orderBy, mode);
+
+            return await query.Select(select).ToListAsync();
+        }
+
         public override Task<bool> Delete(TEntity entity)
         {
             if (entity == null)

NetCoreEntityFramework/Repositories/IEntityRepository.cs

@@ -38,12 +38,44 @@ Task<IEnumerable<TEntity>> GetList(
         /// <param name="where">The filter expression.</param>
         /// <param name="orderByExpression">The expression to order by.</param>
         /// <param name="orderBy">To order by ascending or descending.</param>
-        /// <exception cref="ArgumentException"></exception>
         Task<IEnumerable<TEntity>> GetList(
             Expression<Func<TEntity, bool>> where = null,
             Expression<Func<TEntity, object>> orderByExpression = null,
             OrderBy orderBy = OrderBy.Ascending);
 
+        /// <summary>
+        /// Get multiple entities paginated and translated.
+        /// </summary>
+        /// <typeparam name="TResult">The type to return.</typeparam>
+        /// <param name="select">The select statement to get <typeparamref name="TResult"/>.</param>
+        /// <param name="page">Which page to fetch (1 and above).</param>
+        /// <param name="pageSize">The size of each page (1 and above).</param>
+        /// <param name="where">The filter expression.</param>
+        /// <param name="orderByExpression">The expression to order by.</param>
+        /// <param name="orderBy">To order by ascending or descending.</param>
+        /// <exception cref="ArgumentException"></exception>
+        Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            [Range(1, int.MaxValue)] int page,
+            [Range(1, int.MaxValue)] int pageSize,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending);
+
+        /// <summary>
+        /// Get multiple entities translated.
+        /// </summary>
+        /// <typeparam name="TResult">The type to return.</typeparam>
+        /// <param name="select">The select statement to get <typeparamref name="TResult"/>.</param>
+        /// <param name="where">The filter expression.</param>
+        /// <param name="orderByExpression">The expression to order by.</param>
+        /// <param name="orderBy">To order by ascending or descending.</param>
+        Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending);
+
         /// <summary>
         /// Add the given <paramref name="entity"/> to the database.
         /// An ID will be generated if not provided.

NetCoreEntityFramework/Repositories/IEntitySoftDeleteRepository.cs

@@ -42,13 +42,49 @@ Task<IEnumerable<TEntity>> GetList(
         /// <param name="orderByExpression">The expression to order by.</param>
         /// <param name="orderBy">To order by ascending or descending.</param>
         /// <param name="mode">Whether to include deleted or not.</param>
-        /// <exception cref="ArgumentException"></exception>
         Task<IEnumerable<TEntity>> GetList(
             Expression<Func<TEntity, bool>> where = null,
             Expression<Func<TEntity, object>> orderByExpression = null,
             OrderBy orderBy = OrderBy.Ascending,
             GetListMode mode = GetListMode.ExcludeDeleted);
 
+        /// <summary>
+        /// Get multiple entities paginated and translated.
+        /// </summary>
+        /// <typeparam name="TResult">The type to return.</typeparam>
+        /// <param name="select">The select statement to get <typeparamref name="TResult"/>.</param>
+        /// <param name="page">Which page to fetch (1 and above).</param>
+        /// <param name="pageSize">The size of each page (1 and above).</param>
+        /// <param name="where">The filter expression.</param>
+        /// <param name="orderByExpression">The expression to order by.</param>
+        /// <param name="orderBy">To order by ascending or descending.</param>
+        /// <param name="mode">Whether to include deleted or not.</param>
+        /// <exception cref="ArgumentException"></exception>
+        Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            [Range(1, int.MaxValue)] int page,
+            [Range(1, int.MaxValue)] int pageSize,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending,
+            GetListMode mode = GetListMode.ExcludeDeleted);
+
+        /// <summary>
+        /// Get multiple entities translated.
+        /// </summary>
+        /// <typeparam name="TResult">The type to return.</typeparam>
+        /// <param name="select">The select statement to get <typeparamref name="TResult"/>.</param>
+        /// <param name="where">The filter expression.</param>
+        /// <param name="orderByExpression">The expression to order by.</param>
+        /// <param name="orderBy">To order by ascending or descending.</param>
+        /// <param name="mode">Whether to include deleted or not.</param>
+        Task<IEnumerable<TResult>> GetListWithSelect<TResult>(
+            Expression<Func<TEntity, TResult>> select,
+            Expression<Func<TEntity, bool>> where = null,
+            Expression<Func<TEntity, object>> orderByExpression = null,
+            OrderBy orderBy = OrderBy.Ascending,
+            GetListMode mode = GetListMode.ExcludeDeleted);
+
         /// <summary>
         /// Restore/undelete the entity with the given <paramref name="id"/>.
         /// </summary>