Implemented select for soft delete repository

Author: Morten Turn Pedersen

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/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/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>