Basic delete from DB working

Luticate2.Auth.Tests/DataAccess/Crud/LuEfCrudTests.cs

                 Assert.Null(o.Added.OptionalInt);
             }
         }
+
+        [Fact]
+        public void TestSimpleDelete1()
+        {
+            AddTableSimple1DataSet1();
+
+            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();
+
+            var partialResponse = new LuPartialFieldsDbo
+            {
+                Fields = new List<LuFieldDbo>
+                {
+                    new LuFieldDbo
+                    {
+                        Parts = new List<string>
+                        {
+                            "*"
+                        }
+                    }
+                }
+            };
+
+            var paginationParams = new LuPaginatedParamsDbo
+            {
+                Filter = new LuFilterDbo
+                {
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1")
+                },
+                Page = 0,
+                OrderBy = new LuOrderByDbo
+                {
+                    OrderByFields = new List<LuOrderByFieldDbo>
+                    {
+                        new LuOrderByFieldDbo
+                        {
+                            Asc = false,
+                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Name)
+                        }
+                    }
+                },
+                PerPage = 10
+            };
+
+            var result = crudDataAccess.Delete(partialResponse, paginationParams);
+            Assert.NotNull(result);
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var items = result.Data;
+            Assert.NotNull(items);
+            Assert.Equal(1, items.Count);
+
+            var item = items.Data[0];
+            Assert.NotNull(item);
+            Assert.Equal("test1", item.Name);
+            Assert.Equal(42, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Null(item.OptionalInt);
+        }
+
+        [Fact]
+        public void TestSimpleDelete2()
+        {
+            AddTableSimple1DataSet1();
+
+            var crudDataAccess = ServiceProvider.GetRequiredService<TableSimple1DataAccess>();
+
+            var partialResponse = new LuPartialFieldsDbo
+            {
+                Fields = new List<LuFieldDbo>
+                {
+                    new LuFieldDbo
+                    {
+                        Parts = new List<string>
+                        {
+                            "*"
+                        }
+                    }
+                }
+            };
+
+            var paginationParams = new LuPaginatedParamsDbo
+            {
+                Filter = new LuFilterDbo
+                {
+                    Expression = (Expression<Func<TableSimple1Dbo, bool>>) (x => x.Name == "test1" || x.Name == "test2")
+                },
+                Page = 0,
+                OrderBy = new LuOrderByDbo
+                {
+                    OrderByFields = new List<LuOrderByFieldDbo>
+                    {
+                        new LuOrderByFieldDbo
+                        {
+                            Asc = false,
+                            Expression = (Expression<Func<TableSimple1Dbo, object>>) (x => x.Name)
+                        }
+                    }
+                },
+                PerPage = 10
+            };
+
+            var result = crudDataAccess.Delete(partialResponse, paginationParams);
+            Assert.NotNull(result);
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var items = result.Data;
+            Assert.NotNull(items);
+            Assert.Equal(2, items.Count);
+
+            var item = items.Data[0];
+            Assert.NotNull(item);
+            Assert.Equal("test2", item.Name);
+            Assert.Equal(24, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Equal(1, item.OptionalInt);
+
+            item = items.Data[1];
+            Assert.NotNull(item);
+            Assert.Equal("test1", item.Name);
+            Assert.Equal(42, item.Priority);
+            Assert.Null(item.Comment);
+            Assert.Null(item.OptionalInt);
+        }
     }
 }

Luticate2.Auth/Utils/DataAccess/Crud/LuEfCrudDataAccess.cs

             };
         }
 
-        protected virtual LuResult<TTypeTo> Convert<TTypeTo>(LuPartialFieldsDbo partialInput, object dbo, LuConvertersOptions options) where TTypeTo : class
+        protected virtual LuResult<TTypeTo> Convert<TTypeTo>(LuPartialFieldsDbo partialResponse, object dbo, LuConvertersOptions options) where TTypeTo : class
         {
             var typeTo = dbo.GetType();
             var converterType = typeof(ILuObjectConverter<,>);
                 return dstObjResult.To<TTypeTo>();
             }
             var dstObj = dstObjResult.Data;
-            var result = converter.Convert(dbo, dstObj, new LuFieldDbo(), partialInput, options);
+            var result = converter.Convert(dbo, dstObj, new LuFieldDbo(), partialResponse, options);
             return result.Select(o => o as TTypeTo);
         }
 
+        protected virtual LuResult<IList<TTypeTo>> Convert<TTypeTo>(LuPartialFieldsDbo partialResponse, IEnumerable<object> dbos, LuConvertersOptions options) where TTypeTo : class
+        {
+            var dboList = new List<TTypeTo>();
+            foreach (var model in dbos)
+            {
+                var dboResult = Convert<TTypeTo>(partialResponse, model, options);
+                if (!dboResult)
+                {
+                    return dboResult.To<IList<TTypeTo>>();
+                }
+                var dbo = dboResult.Data;
+
+                dboList.Add(dbo);
+            }
+
+            return LuResult<IList<TTypeTo>>.Ok(dboList);
+        }
+
         protected virtual LuResult<T> HandleError<T>(Exception e)
         {
             return LuResult<T>.Error(LuStatus.DbError.ToInt(), e);
             return LuResult<IQueryable<TModel>>.Ok(paginated);
         }
 
+        protected virtual LuResult<LuPaginatedDbo<TModel>> Paginate(LuPaginatedParamsDbo paginationParams, LuPartialFieldsDbo partialResponse, IQueryable<TModel> set, LuConvertersOptions options)
+        {
+            var includeResult = Include(partialResponse, set);
+            if (!includeResult)
+            {
+                return includeResult.To<LuPaginatedDbo<TModel>>();
+            }
+            var included = includeResult.Data;
+
+            var orderByResult = OrderBy(paginationParams.OrderBy, included, options);
+            if (!orderByResult)
+            {
+                return orderByResult.To<LuPaginatedDbo<TModel>>();
+            }
+            var ordered = orderByResult.Data;
+
+            var filteredResult = Filter(paginationParams.Filter, ordered, options);
+            if (!filteredResult)
+            {
+                return filteredResult.To<LuPaginatedDbo<TModel>>();
+            }
+            var filtered = filteredResult.Data;
+            var count = filtered.Count();
+
+            var paginatedResult = Paginate(paginationParams.Page, paginationParams.PerPage, filtered);
+            if (!paginatedResult)
+            {
+                return paginatedResult.To<LuPaginatedDbo<TModel>>();
+            }
+            var paginated = paginatedResult.Data;
+
+            var paginatedData = new LuPaginatedDbo<TModel>
+            {
+                Data = paginated.ToList(),
+                Count = count
+            };
+
+            return LuResult<LuPaginatedDbo<TModel>>.Ok(paginatedData);
+        }
+
         public virtual LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<object> dbos)
         {
             var options = GetOptions();
             {
                 var options = GetOptions();
 
-                var includeResult = Include(partialResponse, set);
-                if (!includeResult)
-                {
-                    return includeResult.To<LuPaginatedDbo<TDbo>>();
-                }
-                var included = includeResult.Data;
-
-                var orderByResult = OrderBy(paginationParams.OrderBy, included, options);
-                if (!orderByResult)
-                {
-                    return orderByResult.To<LuPaginatedDbo<TDbo>>();
-                }
-                var ordered = orderByResult.Data;
-                
-                var filteredResult = Filter(paginationParams.Filter, ordered, options);
-                if (!filteredResult)
-                {
-                    return filteredResult.To<LuPaginatedDbo<TDbo>>();
-                }
-                var filtered = filteredResult.Data;
-                var count = filtered.Count();
-
-                var paginatedResult = Paginate(paginationParams.Page, paginationParams.PerPage, filtered);
+                var paginatedResult = Paginate(paginationParams, partialResponse, set, options);
                 if (!paginatedResult)
                 {
                     return paginatedResult.To<LuPaginatedDbo<TDbo>>();
                 }
                 var paginated = paginatedResult.Data;
 
-                var dboList = new List<TDbo>();
-                foreach (var model in paginated)
+                var dboListResult = Convert<TDbo>(partialResponse, paginated.Data, options);
+                if (!dboListResult)
                 {
-                    var dboResult = Convert<TDbo>(partialResponse, model, options);
-                    if (!dboResult)
-                    {
-                        return dboResult.To<LuPaginatedDbo<TDbo>>();
-                    }
-                    var dbo = dboResult.Data;
-
-                    dboList.Add(dbo);
+                    return dboListResult.To<LuPaginatedDbo<TDbo>>();
                 }
+                var dboList = dboListResult.Data;
 
-                return LuResult<LuPaginatedDbo<TDbo>>.Ok(new LuPaginatedDbo<TDbo>
+                var paginatedData = new LuPaginatedDbo<TDbo>
                 {
-                    Count = count,
+                    Count = paginated.Count,
                     Data = dboList
-                });
+                };
+
+                return LuResult<LuPaginatedDbo<TDbo>>.Ok(paginatedData);
             });
             return result;
         }
 
-        public virtual LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
+        public virtual LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<object> dbos)
         {
             throw new NotImplementedException();
         }
 
-        public virtual LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
+        public virtual LuResult<LuPaginatedDbo<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams)
         {
-            throw new NotImplementedException();
+            var res = Execute((context, set) =>
+            {
+                var options = GetOptions();
+
+                var paginatedResult = Paginate(paginationParams, partialResponse, set, options);
+                if (!paginatedResult)
+                {
+                    return paginatedResult.To<LuPaginatedDbo<TDbo>>();
+                }
+                var paginated = paginatedResult.Data;
+
+                var dboListResult = Convert<TDbo>(partialResponse, paginated.Data, options);
+                if (!dboListResult)
+                {
+                    return dboListResult.To<LuPaginatedDbo<TDbo>>();
+                }
+                var dboList = dboListResult.Data;
+
+                set.RemoveRange(paginated.Data);
+                context.SaveChanges();
+
+                var paginatedData = new LuPaginatedDbo<TDbo>
+                {
+                    Count = paginated.Count,
+                    Data = dboList
+                };
+
+                return LuResult<LuPaginatedDbo<TDbo>>.Ok(paginatedData);
+            });
+
+            return res;
         }
     }
 }

Luticate2.Auth/Utils/Interfaces/ILuCrud.cs

 
 namespace Luticate2.Auth.Utils.Interfaces
 {
+    // TODO async?
     public interface ILuCrud<TDbo>
     {
         LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<object> dbos);
         
         LuResult<LuPaginatedDbo<TDbo>> Read(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams);
         
-        LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos);
+        LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<object> dbos);
         
-        LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos);
+        LuResult<LuPaginatedDbo<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams);
     }
 }