added transaction on crud delete; tests

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 
 
 
+        protected virtual LuResult<T> _Add<T>(TDboCreate obj, TDbContext db, DbSet<TModel> table)
+        {
+            return LuResult<T>.Ok(default(T));
+        }
 
         public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
         {
-            var models = objs.Select(GetModelFromTCreate).ToList();
+            var models = new List<TModel>();
             var addRes = Execute((db, table) =>
             {
-                table.AddRange(models);
+                var transact = BeginTransaction(db);
+                foreach (var dbo in objs)
+                {
+                    var model = GetModelFromTCreate(dbo);
+                    table.Add(model);
+                    models.Add(model);
+                    var res = _Add<T>(dbo, db, table);
+                    if (!res)
+                    {
+                        return res;
+                    }
+                }
                 db.SaveChanges();
                 foreach (var model in models)
                 {
                     db.Entry(model).State = EntityState.Detached;
                 }
+                CommitTransaction(transact);
                 return LuResult<T>.Ok(default(T));
             });
             if (!addRes)
 
 
 
-        public virtual LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
-            Func<IEnumerable<TDboRead>, T> returnFunc)
+
+//        public virtual LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
+//            Func<IEnumerable<TDboRead>, T> returnFunc)
+//        {
+//            IList<TModel> models = null;
+//            var editRes = Execute((db, table) =>
+//            {
+//                models = GetEditQueryable(db, table).Where(predicate).AsNoTracking().ToList();
+//                foreach (var model in models)
+//                {
+//                    update(model);
+//                    db.Entry(model).State = EntityState.Modified;
+//                }
+//                db.SaveChanges();
+//                return LuResult<T>.Ok(default(T));
+//            });
+//            if (!editRes)
+//            {
+//                return editRes;
+//            }
+//            return GetMultiple(models, returnFunc);
+//        }
+//
+//        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 virtual LuResult<IEnumerable<TDboRead>> EditDbo(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
+//        {
+//            return Edit(predicate, update, read => read);
+//        }
+
+
+//        public virtual LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
+//        {
+//            var guid = GetId(id);
+//            if (guid == null)
+//            {
+//                return GetNotFoundResult<T>();
+//            }
+//            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)), update,
+//                list => returnFunc(list.FirstOrDefault()));
+//        }
+//
+//        public virtual LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
+//        {
+//            return EditSingleById(id, update, GetIdFunc<TId>());
+//        }
+//
+//        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
+//        {
+//            return EditSingleById(id, update, read => read);
+//        }
+
+        protected virtual LuResult<T> _EditSingleById<T>(TId id, TModel model, TDboUpdate obj, TDbContext db, DbSet<TModel> table)
+        {
+            return LuResult<T>.Ok(default(T));
+        }
+
+        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
         {
-            IList<TModel> models = null;
+            var guid = GetId(id);
+            if (guid == null)
+            {
+                return GetNotFoundResult<T>();
+            }
+            var transact = BeginTransaction(null);
             var editRes = Execute((db, table) =>
             {
-                models = GetEditQueryable(db, table).Where(predicate).AsNoTracking().ToList();
-                foreach (var model in models)
+                var model = GetEditQueryable(db, table).FirstOrDefault(GetExpression(new KeyValuePair<string, object>("id", guid)));
+                EditModelFromTUpdate(update, model);
+                var res = _EditSingleById<T>(id, model, update, db, table);
+                if (!res)
                 {
-                    update(model);
-                    db.Entry(model).State = EntityState.Modified;
+                    RollbackTransaction(transact);
+                    return res;
                 }
+                db.Entry(model).State = EntityState.Modified;
                 db.SaveChanges();
                 return LuResult<T>.Ok(default(T));
             });
             if (!editRes)
             {
+                RollbackTransaction(transact);
                 return editRes;
             }
-            return GetMultiple(models, returnFunc);
-        }
-
-        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 virtual LuResult<IEnumerable<TDboRead>> EditDbo(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
-        {
-            return Edit(predicate, update, read => read);
-        }
-
-
-        public virtual LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
-        {
-            var guid = GetId(id);
-            if (guid == null)
-            {
-                return GetNotFoundResult<T>();
-            }
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)), update,
-                list => returnFunc(list.FirstOrDefault()));
-        }
-
-        public virtual LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
-        {
-            return EditSingleById(id, update, GetIdFunc<TId>());
-        }
-
-        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
-        {
-            return EditSingleById(id, update, read => read);
-        }
-
-
-        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
-        {
-            var guid = GetId(id);
-            if (guid == null)
-            {
-                return GetNotFoundResult<T>();
-            }
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)),
-                model => EditModelFromTUpdate(update, model), list => returnFunc(list.FirstOrDefault()));
+            var getRes = GetSingleById(id).To(returnFunc);
+            CommitTransaction(transact);
+            return getRes;
         }
 
         public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
         {
             return Execute((db, table) =>
             {
+                var transact = BeginTransaction(db);
                 var models = GetDeleteQueryable(db, table).Where(predicate).AsNoTracking().ToList();
                 var getRes = GetMultiple(models, returnFunc);
                 if (!getRes)
                 {
+                    RollbackTransaction(transact);
                     return getRes;
                 }
                 table.RemoveRange(models);
                 db.SaveChanges();
+                CommitTransaction(transact);
                 return getRes;
             });
         }