added dbo/model conversion tools; added add/edit hooks; tests

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 
 
 
-        protected virtual LuResult<TModel> _Add(TDboCreate dbo, TDbContext db, DbSet<TModel> table)
+        protected virtual LuResult<bool> _Add(TModel model, TDboCreate dbo, TDbContext db, DbSet<TModel> table)
         {
-            return LuResult<TModel>.Ok(GetModelFromTCreate(dbo));
+            return LuResult<bool>.Ok(true);
         }
 
         public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
                 var transact = BeginTransaction(db);
                 foreach (var dbo in objs)
                 {
-                    var res = _Add(dbo, db, table);
+                    var model = GetModelFromTCreate(dbo);
+                    table.Add(model);
+                    models.Add(model);
+                    var res = _Add(model, dbo, db, table);
                     if (!res)
                     {
                         RollbackTransaction(transact);
                         return res.To<T>();
                     }
-                    table.Add(res.Data);
-                    models.Add(res.Data);
                 }
                 db.SaveChanges();
-                foreach (var model in models)
-                {
-                    db.Entry(model).State = EntityState.Detached;
-                }
                 CommitTransaction(transact);
                 return LuResult<T>.Ok(default(T));
             });
         {
             return Execute((db, table) =>
             {
-                var model = GetGetQueryable(db, table).AsNoTracking().FirstOrDefault(predicate);
+                var model = GetGetQueryable(db, table).FirstOrDefault(predicate);
                 if (model == default(TModel))
                 {
                     return GetNotFoundResult<TDboRead>();
                 {
                     ordered = func(ordered);
                 }
-                var data = ordered.Where(predicate).Skip(page * perPage).Take(perPage).AsNoTracking().Select(GetDboFromModel).ToList();
+                var data = ordered.Where(predicate).Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
                 var result = new LuPaginatedDbo<TDboRead>
                 {
                     Count = count,
                     if (exp == null)
                     {
                         return LuResult<LuPaginatedDbo<TDboRead>>.Error(LuStatus.InputError,
-                            string.Format("LuEfCrudDataAccess: {0}", field.Name), "Invalid order by field");
+                            $"LuEfCrudDataAccess: {field.Name}", "Invalid order by field");
                     }
                     if (ordered != null)
                     {
                     }
                 }
 
-                var data = ordered.Skip(page * perPage).Take(perPage).AsNoTracking().Select(GetDboFromModel).ToList();
+                var data = ordered.Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
                 var result = new LuPaginatedDbo<TDboRead>
                 {
                     Count = count,
 //            IList<TModel> models = null;
 //            var editRes = Execute((db, table) =>
 //            {
-//                models = GetEditQueryable(db, table).Where(predicate).AsNoTracking().ToList();
+//                models = GetEditQueryable(db, table).Where(predicate).ToList();
 //                foreach (var model in models)
 //                {
 //                    update(model);
-//                    db.Entry(model).State = EntityState.Modified;
 //                }
 //                db.SaveChanges();
 //                return LuResult<T>.Ok(default(T));
 //            return EditSingleById(id, update, read => read);
 //        }
 
-        protected virtual LuResult<bool> _EditSingleById(TId id, TModel model, TDboUpdate update, TDbContext db, DbSet<TModel> table)
+        protected virtual LuResult<bool> _EditSingleById(TModel model, TDboUpdate update, TDbContext db, DbSet<TModel> table)
         {
-            EditModelFromTUpdate(update, model);
             return LuResult<bool>.Ok(true);
         }
 
             var editRes = Execute((db, table) =>
             {
                 var model = GetEditQueryable(db, table).FirstOrDefault(GetExpression(new KeyValuePair<string, object>("id", guid)));
-                var res = _EditSingleById(id, model, update, db, table);
+                EditModelFromTUpdate(update, model);
+                db.SaveChanges();
+                var res = _EditSingleById(model, update, db, table);
                 if (!res)
                 {
                     RollbackTransaction(transact);
                     return res.To<T>();
                 }
-                db.Entry(model).State = EntityState.Modified;
                 db.SaveChanges();
                 return LuResult<T>.Ok(default(T));
             });
             return Execute((db, table) =>
             {
                 var transact = BeginTransaction(db);
-                var models = GetDeleteQueryable(db, table).Where(predicate).AsNoTracking().ToList();
+                var models = GetDeleteQueryable(db, table).Where(predicate).ToList();
                 var getRes = GetMultiple(models, returnFunc);
                 if (!getRes)
                 {

Luticate2.Utils/Utils/LuCoreUtilsExtensions.cs

             return string.Concat(str.Select((x, i) => i > 0 && char.IsUpper(x) ? "_" + x.ToString() : x.ToString())).ToLower();
         }
 
+        public static T ToOptEnum<T>(this string model)
+        {
+            return model == null ? default(T) : (T) Enum.Parse(typeof(T), model);
+        }
+
         public static T ToEnum<T>(this string model)
         {
             return (T) Enum.Parse(typeof(T), model);
         }
 
-        public static Guid? ToGuid(this string str)
+        public static Guid? ToOptGuid(this string str)
         {
             return str == null ? (Guid?)null : new Guid(str);
         }
 
+        public static Guid ToGuid(this string str)
+        {
+            return new Guid(str);
+        }
+
         public static string ToDbo(this Guid model)
         {
             return model.ToString();

TestUtils/DataAccess/LuUtilsPkGuidDataAccess.cs

             return model => LuUtilsDbContext.lu_texts_match(filter.Query, model.some_text + " " + model.some_int.ToString());
         }
 
-        protected override LuResult<pk_guid> _Add(PkGuidAddDbo dbo, LuUtilsDbContext db, DbSet<pk_guid> table)
+        protected override LuResult<bool> _Add(pk_guid model, PkGuidAddDbo dbo, LuUtilsDbContext db, DbSet<pk_guid> table)
         {
             if (dbo.SomeInt == 2424)
             {
             }
             if (dbo.SomeInt == 4242)
             {
-                return LuResult<pk_guid>.Error(LuStatus.DbError, "Some expected error", "");
+                return LuResult<bool>.Error(LuStatus.DbError, "Some expected error", "");
             }
-            return LuResult<pk_guid>.Ok(GetModelFromTCreate(dbo));
+            return LuResult<bool>.Ok(true);
+        }
+
+        protected override LuResult<bool> _EditSingleById(pk_guid model, PkGuidAddDbo update, LuUtilsDbContext db, DbSet<pk_guid> table)
+        {
+            return LuResult<bool>.Ok(true);
         }
     }
 }

TestUtils/Utils/LuCoreUtilsExtensionsTest.cs

     public class LuCoreUtilsExtensionsTest
     {
         [Fact]
-        public void TestStringToGuidNull()
+        public void TestStringToOptGuidNull()
         {
             string str = null;
-            Assert.Null(str.ToGuid());
+            Assert.Null(str.ToOptGuid());
         }
 
         [Fact]