made all curd methods virtual

Luticate2.Utils/Business/LuCrudBusiness.cs

             return LuResult<TDboUpdate>.Ok(update);
         }
 
-        protected LuResult<TDboUpdate> GetAndCheckEdit(TId id, TDboUpdate update)
+        protected virtual LuResult<TDboUpdate> GetAndCheckEdit(TId id, TDboUpdate update)
         {
             var res = GetSingleById(id);
             if (!res)
         public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
             int perPage = int.MaxValue)
         {
-            return DataAccess.GetMultiple(orderBy, page, perPage);
+            return GetMultiple(orderBy, new LuFilterDbo { Query = ""}, page, perPage);
         }
 
 

Luticate2.Utils/Controllers/LuController.cs

 
         protected IDictionary<object, object> LuItems => HttpContext.GetLuItems();
 
-        protected LuApiWrapperDbo<T> Handle<T>(LuResult<T> result)
+        protected virtual LuApiWrapperDbo<T> Handle<T>(LuResult<T> result)
         {
             if (result)
             {
             throw new LuResultException(result.To<object>());
         }
 
-        protected LuApiWrapperDbo<LuBoxedValueDbo<T>> HandleBoxed<T>(LuResult<T> result)
+        protected virtual LuApiWrapperDbo<LuBoxedValueDbo<T>> HandleBoxed<T>(LuResult<T> result)
         {
             return Handle(result.To(arg => new LuBoxedValueDbo<T>
             {

Luticate2.Utils/Controllers/LuCrudController.cs

 
         [HttpGet]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> GetSingleById([Required]TId id)
+        public virtual LuApiWrapperDbo<TDboRead> GetSingleById([Required]TId id)
         {
             return Handle(Busines.GetSingleById(id));
         }
 
         [HttpGet]
         [Route("[controller]")]
-        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple([Required]LuPaginatedRequestDbo request)
+        public virtual LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple([Required]LuPaginatedRequestDbo request)
         {
             return Handle(Busines.GetMultiple(request.OrderBy, request.Filter, request.Page, request.PerPage));
         }
 
         [HttpPost]
         [Route("[controller]")]
-        public LuApiWrapperDbo<TDboRead> AddDbo([FromBody][Required]TDboCreate data)
+        public virtual LuApiWrapperDbo<TDboRead> AddDbo([FromBody][Required]TDboCreate data)
         {
             return Handle(Busines.AddDbo(data));
         }
 
         [HttpPost]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo([Required]TId id, [FromBody][Required]TDboUpdate data)
+        public virtual LuApiWrapperDbo<TDboRead> EditSingleByIdDbo([Required]TId id, [FromBody][Required]TDboUpdate data)
         {
             return Handle(Busines.EditSingleByIdDbo(id, data));
         }
 
         [HttpDelete]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> Delete([Required]TId id)
+        public virtual LuApiWrapperDbo<TDboRead> Delete([Required]TId id)
         {
             return Handle(Busines.DeleteSingleByIdDbo(id));
         }

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

             return table;
         }
 
-        protected Func<TDboRead, T> GetIdFunc<T>()
+        protected virtual Func<TDboRead, T> GetIdFunc<T>()
         {
             return x => ((dynamic) x).Id;
         }
 
-        protected TModel GetModelFromTUpdate(TDboUpdate obj, TModel model)
+        protected virtual TModel GetModelFromTUpdate(TDboUpdate obj, TModel model)
         {
             EditModelFromTUpdate(obj, model);
             return model;
         }
 
-        protected LuResult<T> GetNotFoundResult<T>()
+        protected virtual LuResult<T> GetNotFoundResult<T>()
         {
             return LuResult<T>.Error(LuStatus.NotFound, typeof(TModel).Name + ": Value not found", "");
         }
 
-        protected IQueryable<TModel> GetFilterQuery(LuFilterDbo filter, TDbContext db, DbSet<TModel> table)
+        protected virtual IQueryable<TModel> GetFilterQuery(LuFilterDbo filter, TDbContext db, DbSet<TModel> table)
         {
             return GetGetQueryable(db, table).Where(GetFilterExpression(filter));
         }
 
 
 
-        public LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
+        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
         {
             var models = objs.Select(GetModelFromTCreate).ToList();
             var addRes = Execute((db, table) =>
             return GetMultiple(models, returnFunc);
         }
 
-        public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
         {
             return Add(new List<TDboCreate> {obj}, list => returnFunc(list.First()));
         }
 
 
-        public LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
+        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
         {
             var func = GetIdFunc<TId>();
             return Add(objs, list => list.Select(func));
         }
 
-        public LuResult<TId> AddId(TDboCreate obj)
+        public virtual LuResult<TId> AddId(TDboCreate obj)
         {
             return AddId(new List<TDboCreate> {obj}).To(list => list.First());
         }
 
 
-        public LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
+        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
         {
             return Add(obj, read => read);
         }
 
-        public LuResult<TDboRead> AddDbo(TDboCreate obj)
+        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
         {
             return AddDbo(new List<TDboCreate> {obj}).To(list => list.First());
         }
 
 
 
-        public LuResult<TDboRead> GetSingle(Expression<Func<TModel, bool>> predicate)
+        public virtual LuResult<TDboRead> GetSingle(Expression<Func<TModel, bool>> predicate)
         {
             return Execute((db, table) =>
             {
             });
         }
 
-        public LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
+        public virtual LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
         {
             return GetSingle(GetExpression(keys));
         }
 
-        public LuResult<TDboRead> GetSingleById(TId id)
+        public virtual LuResult<TDboRead> GetSingleById(TId id)
         {
             var guid = GetId(id);
             if (guid == null)
             return GetSingleByKeys(new KeyValuePair<string, object>("id", guid));
         }
 
-        protected LuResult<T> GetMultiple<T>(IList<TModel> models, Func<IEnumerable<TDboRead>, T> returnFunc)
+        protected virtual LuResult<T> GetMultiple<T>(IList<TModel> models, Func<IEnumerable<TDboRead>, T> returnFunc)
         {
             var dbos = new List<TDboRead>();
             foreach (var model in models)
             return LuResult<T>.Ok(res);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
             Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
             params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
         {
             });
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
             Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
             params Expression<Func<TModel, object>>[] otherOrderBy)
         {
                     IOrderedQueryable<TModel>>>(expression => (t => t.ThenBy(expression))).ToArray());
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
             int page = 0, int perPage = int.MaxValue, params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
         {
             return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
             int page = 0, int perPage = int.MaxValue, params Expression<Func<TModel, object>>[] otherOrderBy)
         {
             return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, Func<TDbContext, DbSet<TModel>, IQueryable<TModel>> getQueryable,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, Func<TDbContext, DbSet<TModel>, IQueryable<TModel>> getQueryable,
             int page = 0, int perPage = int.MaxValue)
         {
             return Execute((db, table) =>
             });
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
             int page = 0, int perPage = int.MaxValue)
         {
             return GetMultiple(orderBy, (db, table) => GetFilterQuery(filter, db, table), page, perPage);
         }
 
-        public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
         {
             return GetMultiple(orderBy, GetGetQueryable, page, perPage);
         }
 
 
 
-        public LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
+        public virtual LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
             Func<IEnumerable<TDboRead>, T> returnFunc)
         {
             IList<TModel> models = null;
             return GetMultiple(models, returnFunc);
         }
 
-        public LuResult<IEnumerable<TId>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
+        public virtual LuResult<IEnumerable<TId>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
         {
             var func = GetIdFunc<TId>();
             return Edit(predicate, update, reads => reads.Select(func));
         }
 
-        public LuResult<IEnumerable<TDboRead>> EditDbo(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
+        public virtual LuResult<IEnumerable<TDboRead>> EditDbo(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
         {
             return Edit(predicate, update, read => read);
         }
 
 
-        public LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
         {
             var guid = GetId(id);
             if (guid == null)
                 list => returnFunc(list.FirstOrDefault()));
         }
 
-        public LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
+        public virtual LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
         {
             return EditSingleById(id, update, GetIdFunc<TId>());
         }
 
-        public LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
+        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
         {
             return EditSingleById(id, update, read => read);
         }
 
 
-        public LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
         {
             var guid = GetId(id);
             if (guid == null)
                 model => EditModelFromTUpdate(update, model), list => returnFunc(list.FirstOrDefault()));
         }
 
-        public LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
+        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
         {
             return EditSingleById(id, update, GetIdFunc<TId>());
         }
 
-        public LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
+        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
         {
             return EditSingleById(id, update, read => read);
         }
 
 
 
-        public LuResult<T> Delete<T>(Expression<Func<TModel, bool>> predicate,
+        public virtual LuResult<T> Delete<T>(Expression<Func<TModel, bool>> predicate,
             Func<IEnumerable<TDboRead>, T> returnFunc)
         {
             return Execute((db, table) =>
             });
         }
 
-        public LuResult<IEnumerable<TId>> DeleteId(Expression<Func<TModel, bool>> predicate)
+        public virtual LuResult<IEnumerable<TId>> DeleteId(Expression<Func<TModel, bool>> predicate)
         {
             var func = GetIdFunc<TId>();
             return Delete(predicate, reads => reads.Select(func));
         }
 
-        public LuResult<IEnumerable<TDboRead>> DeleteDbo(Expression<Func<TModel, bool>> predicate)
+        public virtual LuResult<IEnumerable<TDboRead>> DeleteDbo(Expression<Func<TModel, bool>> predicate)
         {
             return Delete(predicate, read => read);
         }
 
 
-        public LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
+        public virtual LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
         {
             var guid = GetId(id);
             if (guid == null)
                 reads => returnFunc(reads.FirstOrDefault()));
         }
 
-        public LuResult<TId> DeleteSingleByIdId(TId id)
+        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
         {
             var func = GetIdFunc<TId>();
             return DeleteSingleById(id, func);
         }
 
-        public LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
+        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
         {
             return DeleteSingleById(id, read => read);
         }

Luticate2.Utils/DataAccess/LuEfDataAccess.cs

 
         protected abstract DbSet<TModel> GetTable(TDbContext db);
 
-        public LuResult<T> Execute<T>(Func<TDbContext, DbSet<TModel>, LuResult<T>> func)
+        public virtual LuResult<T> Execute<T>(Func<TDbContext, DbSet<TModel>, LuResult<T>> func)
         {
             try
             {