perform full get after add/edit/delete

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

             return id;
         }
 
+        protected virtual object GetModelId(object id)
+        {
+            var g = id as Guid?;
+            if (g != null)
+            {
+                return g.ToString();
+            }
+            return id;
+        }
+
         protected virtual IQueryable<TModel> GetGetQueryable(TDbContext db, DbSet<TModel> table)
         {
             return table;
 
         public LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
         {
-            return Execute((db, table) =>
+            var models = objs.Select(GetModelFromTCreate).ToList();
+            var addRes = Execute((db, table) =>
             {
-                var models = objs.Select(GetModelFromTCreate).ToList();
                 table.AddRange(models);
                 db.SaveChanges();
                 foreach (var model in models)
                 {
                     db.Entry(model).State = EntityState.Detached;
                 }
-                var dbos = models.Select(GetDboFromModel).ToList();
-                var res = returnFunc(dbos);
-                return LuResult<T>.Ok(res);
+                return LuResult<T>.Ok(default(T));
             });
+            if (!addRes)
+            {
+                return addRes;
+            }
+            return GetMultiple(models, returnFunc);
         }
 
         public LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
             return GetSingleByKeys(new KeyValuePair<string, object>("id", guid));
         }
 
+        protected LuResult<T> GetMultiple<T>(IList<TModel> models, Func<IEnumerable<TDboRead>, T> returnFunc)
+        {
+            var dbos = new List<TDboRead>();
+            foreach (var model in models)
+            {
+                var getRes = GetSingleById((TId) GetModelId(((dynamic)model).id));
+                if (!getRes)
+                {
+                    return getRes.To<T>();
+                }
+                dbos.Add(getRes.Data);
+            }
+            var res = returnFunc(dbos);
+            return LuResult<T>.Ok(res);
+        }
 
         public LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
             Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
         public LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
             Func<IEnumerable<TDboRead>, T> returnFunc)
         {
-            return Execute((db, table) =>
+            IList<TModel> models = null;
+            var editRes = Execute((db, table) =>
             {
-                var models = GetEditQueryable(db, table).Where(predicate).AsNoTracking().ToList();
+                models = GetEditQueryable(db, table).Where(predicate).AsNoTracking().ToList();
                 foreach (var model in models)
                 {
                     update(model);
                     db.Entry(model).State = EntityState.Modified;
                 }
                 db.SaveChanges();
-                var editedDbos = models.Select(GetDboFromModel).ToList();
-                var res = returnFunc(editedDbos);
-                return LuResult<T>.Ok(res);
+                return LuResult<T>.Ok(default(T));
             });
+            if (!editRes)
+            {
+                return editRes;
+            }
+            return GetMultiple(models, returnFunc);
         }
 
         public LuResult<IEnumerable<TId>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
             return Execute((db, table) =>
             {
                 var models = GetDeleteQueryable(db, table).Where(predicate).AsNoTracking().ToList();
+                var getRes = GetMultiple(models, returnFunc);
+                if (!getRes)
+                {
+                    return getRes;
+                }
                 table.RemoveRange(models);
                 db.SaveChanges();
-                var dbos = models.Select(GetDboFromModel);
-                return LuResult<T>.Ok(returnFunc(dbos));
+                return getRes;
             });
         }
 

TestUtils/DataAccess/LuUtilsDbContext.cs

         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             
+            modelBuilder.Entity<fk_pk_guids>()
+                .HasKey(c => new { c.id });
+            
+            modelBuilder.Entity<fk_pk_guids>()
+                .Property(e => e.id)
+                .HasDefaultValueSql("get_uuid()");
+            
+            
+            modelBuilder.Entity<fk_pk_guids>()
+                .HasOne(e => e.fk_pk_guid)
+                .WithMany(e => e.fk_pk_guids_fk)
+                .HasForeignKey("pk_guid_id")
+                .HasConstraintName("fk_pk_guid_pk_guid_id_fkey");
+            
+            
             modelBuilder.Entity<pk_bigserial>()
                 .HasKey(c => new { c.id });
             
             
         }
         
+        public virtual DbSet<fk_pk_guids> fk_pk_guids { get; set; }
+        
         public virtual DbSet<pk_bigserial> pk_bigserial { get; set; }
         
         public virtual DbSet<pk_guid> pk_guid { get; set; }

TestUtils/DataAccess/LuUtilsFkPkGuidDataAccess.cs

+using System;
+using System.Linq;
+using Luticate2.Utils.DataAccess;
+using Microsoft.EntityFrameworkCore;
+using TestUtils.DataAccess.Models;
+using TestUtils.Dbo.FkPkGuid;
+
+namespace TestUtils.DataAccess
+{
+    public class LuUtilsFkPkGuidDataAccess : LuEfCrudDataAccess<fk_pk_guids, FkPkGuidAddDbo, FkPkGuidDbo, FkPkGuidAddDbo, LuUtilsDbContext, string>
+    {
+        public LuUtilsFkPkGuidDataAccess(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override DbSet<fk_pk_guids> GetTable(LuUtilsDbContext db)
+        {
+            return db.fk_pk_guids;
+        }
+
+        protected override IQueryable<fk_pk_guids> GetGetQueryable(LuUtilsDbContext db, DbSet<fk_pk_guids> table)
+        {
+            return table.Include(guids => guids.fk_pk_guid);
+        }
+
+        protected override fk_pk_guids GetModelFromTCreate(FkPkGuidAddDbo obj)
+        {
+            return GetModelFromTUpdate(obj, new fk_pk_guids());
+        }
+
+        protected override void EditModelFromTUpdate(FkPkGuidAddDbo obj, fk_pk_guids model)
+        {
+            model.name = obj.Name;
+            model.pk_guid_id = obj.PkGuidId == null ? (Guid?) null : new Guid(obj.PkGuidId);
+        }
+
+        protected override FkPkGuidDbo GetDboFromModel(fk_pk_guids model)
+        {
+            return new FkPkGuidDbo
+            {
+                Id = model.id.ToString(),
+                Name = model.name,
+                PkGuid = model.fk_pk_guid == null ? null : LuUtilsPkGuidDataAccess.GetDboFromModelStatic(model.fk_pk_guid),
+                PkGuidId = model.pk_guid_id?.ToString()
+            };
+        }
+    }
+}

TestUtils/DataAccess/LuUtilsPkGuidDataAccess.cs

             model.some_text = obj.SomeText;
         }
 
-        protected override PkGuidDbo GetDboFromModel(pk_guid model)
+        public static PkGuidDbo GetDboFromModelStatic(pk_guid model)
         {
             return new PkGuidDbo
             {
             };
         }
 
+        protected override PkGuidDbo GetDboFromModel(pk_guid model)
+        {
+            return GetDboFromModelStatic(model);
+        }
+
         protected override Expression<Func<pk_guid, bool>> GetFilterExpression(LuFilterDbo filter)
         {
             return model => LuUtilsDbContext.lu_texts_match(filter.Query, model.some_text + " " + model.some_int.ToString());

TestUtils/DataAccess/Models/fk_pk_guids.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace TestUtils.DataAccess.Models
+{
+    public partial class fk_pk_guids
+    {
+        
+        public Guid id { get; set; }
+        
+        public string name { get; set; }
+        
+        public Guid? pk_guid_id { get; set; }
+        
+        
+        public virtual pk_guid fk_pk_guid { get; set; }
+        
+        
+    }
+}

TestUtils/DataAccess/Models/pk_guid.cs

         
         
         
+        public virtual IList<fk_pk_guids> fk_pk_guids_fk { get; set; }
+        
     }
 }

TestUtils/DataAccess/code-from-ds/DataSource.twig

 using Microsoft.EntityFrameworkCore;
-using Luticate2.Auth.DataAccess.Models;
-using Test.Utils.DataAccess.Models;
+using TestUtils.DataAccess.Models;
 
 namespace TestUtils.DataAccess
 {

TestUtils/DataAccess/code-from-ds/code-from-ds.json

     "modelsRelativePath": "TestUtils/DataAccess/Models",
     "selection": {
         "tables": [
+            {
+                "columns": [
+                    {
+                        "column": "id",
+                        "selected": true
+                    },
+                    {
+                        "column": "name",
+                        "selected": true
+                    },
+                    {
+                        "column": "pk_guid_id",
+                        "selected": true
+                    }
+                ],
+                "table": "fk_pk_guids"
+            },
             {
                 "columns": [
                     {

TestUtils/Dbo/FkPkGuid/FkPkGuidAddDbo.cs

+namespace TestUtils.Dbo.FkPkGuid
+{
+    public class FkPkGuidAddDbo
+    {
+        public string Name { get; set; }
+
+        public string PkGuidId { get; set; }
+    }
+}

TestUtils/Dbo/FkPkGuid/FkPkGuidDbo.cs

+using TestUtils.Dbo.PkGuid;
+
+namespace TestUtils.Dbo.FkPkGuid
+{
+    public class FkPkGuidDbo
+    {
+        public string Id { get; set; }
+
+        public string Name { get; set; }
+
+        public string PkGuidId { get; set; }
+
+        public PkGuidDbo PkGuid { get; set; }
+    }
+}

TestUtils/EfCrudDataAccess/LuEfCreateDataAccessTest.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Result;
 using TestUtils.DataAccess;
+using TestUtils.Dbo.FkPkGuid;
 using TestUtils.Dbo.PkBigSerial;
 using TestUtils.Dbo.PkGuid;
 using Xunit;
 
-namespace TestUtils.EfCrubDataAccesss
+namespace TestUtils.EfCrudDataAccess
 {
     public class LuEfCreateDataAccessTest
     {
                 Assert.Equal(res.Data.Id, get.Data.Id);
             });
         }
+
+
+        [Fact]
+        public void TestAddDboSingleFk1()
+        {
+            Tests.TestRealDb(context =>
+            {
+                var pkGuidDataAccess = new LuUtilsPkGuidDataAccess(context);
+                var fkPkGuidDataAccess = new LuUtilsFkPkGuidDataAccess(context);
+                var pkGuidDbo = pkGuidDataAccess.AddDbo(new PkGuidAddDbo
+                {
+                    SomeInt = 42,
+                    SomeText = "Test."
+                });
+                Assert.Equal(LuStatus.Success, pkGuidDbo.Status);
+                var fkPkGuidDbo = fkPkGuidDataAccess.AddDbo(new FkPkGuidAddDbo
+                {
+                    Name = "Test.",
+                    PkGuidId = pkGuidDbo.Data.Id
+                });
+                Assert.Equal(LuStatus.Success, fkPkGuidDbo.Status);
+                Assert.NotNull(fkPkGuidDbo.Data.PkGuid);
+                Assert.Equal(pkGuidDbo.Data.Id, fkPkGuidDbo.Data.PkGuid.Id);
+            });
+        }
     }
 }

TestUtils/Tests.cs

 using System;
+using System.Linq;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using TestUtils.DataAccess;
             serviceCollection.AddDbContext<LuUtilsDbContext>(builder => builder.UseNpgsql(ConnectionString),
                 ServiceLifetime.Transient);
             var serviceProvider = serviceCollection.BuildServiceProvider();
-            var dbContext = (LuUtilsDbContext)serviceProvider.GetService(typeof(LuUtilsDbContext));
             try
             {
                 func(serviceProvider);
             }
             finally
             {
+                var dbContext = (LuUtilsDbContext)serviceProvider.GetService(typeof(LuUtilsDbContext));
                 dbContext.pk_bigserial.RemoveRange(dbContext.pk_bigserial);
                 dbContext.pk_guid.RemoveRange(dbContext.pk_guid);
+                dbContext.fk_pk_guids.RemoveRange(dbContext.fk_pk_guids);
+
                 dbContext.SaveChanges();
                 dbContext.Dispose();
             }

TestUtils/project.json

     },
     "dependencies": {
         "dotnet-test-xunit": "1.0.0-rc2-*",
-        "Luticate2.Utils": "0.1.*",
+        "Luticate2.Utils": "0.2.*",
         "Moq": "4.6.38-alpha",
         "System.Runtime.Serialization.Primitives": "4.1.1",
         "xunit": "2.1.0"

WebApiUtils/project.json

 {
     "dependencies": {
-        "Luticate2.Utils": "0.1.*",
+        "Luticate2.Utils": "0.2.*",
         "TestUtils": "0.1.*",
         "Microsoft.ApplicationInsights.AspNetCore": "1.0.2",
         "Microsoft.AspNetCore.Mvc": "1.1.0",