Added partial copy support in LuObjectConverter and tests

Luticate2.Auth.Tests/Business/ObjectConverter/ObjectConverterTests.cs

 using Luticate2.Auth.Utils.Business.ObjectConverter;
 using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
 using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
             return options;
         }
 
-        [Fact]
-        void Test1()
+        protected TestModel1 GetBasicModel()
         {
-            var serviceProvider = GetServiceProvider();
-            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
-            var model = new TestModel1
+            return new TestModel1
             {
                 id = Guid.NewGuid(),
                 name = "Test.",
                     }
                 }
             };
-            var result = converter.Convert(model, LuPartialFieldsParser.Parse("*").Data, GetConverterOptions());
+        }
+
+        [Fact]
+        public void TestBasic1()
+        {
+            var serviceProvider = GetServiceProvider();
+            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
+            var model = GetBasicModel();
+            var result = converter.Convert(model, new LuFieldDbo(), LuPartialFieldsParser.Parse("*").Data, GetConverterOptions());
             Assert.Equal(LuStatus.Success.ToInt(), result.Status);
             var dbo = result.Data as TestDbo1;
             Assert.NotNull(dbo);
             Assert.Equal(model.id, dbo.Id);
             Assert.Equal(model.name, dbo.Name);
+            Assert.NotNull(dbo.TestDbo2s);
             Assert.Equal(model.test_model2.Count, dbo.TestDbo2s.Count);
             foreach (var e in model.test_model2.Zip(dbo.TestDbo2s, (model2, dbo2) => new {Model = model2, Dbo = dbo2}))
             {
                 Assert.Null(e.Dbo.TestDbo1);
             }
         }
+
+        [Fact]
+        void TestPath1()
+        {
+            var serviceProvider = GetServiceProvider();
+            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
+            var model = GetBasicModel();
+            var result = converter.Convert(model, new LuFieldDbo(), LuPartialFieldsParser.Parse("Id").Data, GetConverterOptions());
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var dbo = result.Data as TestDbo1;
+            Assert.NotNull(dbo);
+            Assert.Equal(model.id, dbo.Id);
+            Assert.Null(dbo.Name);
+            Assert.Null(dbo.TestDbo2s);
+        }
+
+        [Fact]
+        void TestPath2()
+        {
+            var serviceProvider = GetServiceProvider();
+            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
+            var model = GetBasicModel();
+            var result = converter.Convert(model, new LuFieldDbo(), LuPartialFieldsParser.Parse("id").Data, GetConverterOptions());
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var dbo = result.Data as TestDbo1;
+            Assert.NotNull(dbo);
+            Assert.Equal(model.id, dbo.Id);
+            Assert.Null(dbo.Name);
+            Assert.Null(dbo.TestDbo2s);
+        }
+
+        [Fact]
+        public void TestPath3()
+        {
+            var serviceProvider = GetServiceProvider();
+            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
+            var model = GetBasicModel();
+            var result = converter.Convert(model, new LuFieldDbo(), LuPartialFieldsParser.Parse("Id, TestDbo2s(Id, Name)").Data, GetConverterOptions());
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var dbo = result.Data as TestDbo1;
+            Assert.NotNull(dbo);
+            Assert.Equal(model.id, dbo.Id);
+            Assert.Null(dbo.Name);
+            Assert.NotNull(dbo.TestDbo2s);
+            Assert.Equal(model.test_model2.Count, dbo.TestDbo2s.Count);
+            foreach (var e in model.test_model2.Zip(dbo.TestDbo2s, (model2, dbo2) => new {Model = model2, Dbo = dbo2}))
+            {
+                Assert.Equal(e.Model.id, e.Dbo.Id);
+                Assert.Equal(e.Model.name, e.Dbo.Name);
+                Assert.Null(e.Dbo.NameVirtual);
+                Assert.Null(e.Dbo.Parent);
+                Assert.Null(e.Dbo.TestDbo1);
+            }
+        }
     }
 }

Luticate2.Auth/Utils/Business/Crud/LuEfCrudBusiness.cs

                 return LuResult<TModel>.Error(LuStatus.InternalError.ToInt(),
                     $"Could not get service: {nameof(ILuObjectConverter)}<{typeof(TDbo).Name}, {typeof(TModel).Name}>");
             }
-            var result = copier.Convert(dbo, partialInput, GetOptions());
+            var result = copier.Convert(dbo, new LuFieldDbo(), partialInput, GetOptions());
             return result.Select(o => o as TModel);
         }
 
                 return LuResult<TDbo>.Error(LuStatus.InternalError.ToInt(),
                     $"Could not get service: {nameof(ILuObjectConverter)}<{typeof(TModel).Name}, {typeof(TDbo).Name}>");
             }
-            var result = copier.Convert(model, partialResponse, GetOptions());
+            var result = copier.Convert(model, new LuFieldDbo(), partialResponse, GetOptions());
             return result.Select(o => o as TDbo);
         }
 

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterIdentity.cs

 {
     public class LuObjectConverterIdentity : ILuObjectConverterIdentity
     {
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
+        public LuResult<object> Convert(object srcObj, LuFieldDbo path, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
+            // TODO Handle path
             return LuResult<object>.Ok(srcObj);
         }
     }

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterLists.cs

 
         protected abstract Type GetListType();
 
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
+        public LuResult<object> Convert(object srcObj, LuFieldDbo path, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
             if (srcObj is IEnumerable enumerable)
             {
                         var typeTo = options.TypeConverter.ConvertType(typeFrom);
                         // TODO Handle converter == null
                         var converter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, typeFrom, typeTo);
-                        var convertResult = converter.Convert(obj, fields, options);
+                        var convertResult = converter.Convert(obj, path, fields, options);
                         if (!convertResult)
                         {
                             return convertResult;

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterPoco.cs

 using System;
+using Luticate2.Auth.Utils.Business.Fields;
 using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
             ServiceProvider = serviceProvider;
         }
 
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
+        public LuResult<object> Convert(object srcObj, LuFieldDbo path, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
-            // TODO Check if this is correct
             if (srcObj == null)
             {
                 return LuResult<object>.Ok(default(TTypeTo));
             foreach (var memberInfo in typeTo.GetProperties())
             {
                 // TODO check if field is included in fields
+                var memberPath = LuFieldDbo.Make(path).Add(memberInfo.Name);
+                if (!fields.Fields.IsIncluded(memberPath))
+                {
+                    continue;
+                }
                 // TODO Handle srcPropExpression == null
                 var srcPropExpression = descriptor.GetMemberValueExpression(memberInfo, options.DescriptorOptions);
                 var srcPropDelegate = srcPropExpression.Compile();
 
                 // TODO Handle objectConverter == null
                 var objectConverter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, srcType, dstType);
-                var dstPropResult = objectConverter.Convert(srcProp, fields, options);
+                var dstPropResult = objectConverter.Convert(srcProp, memberPath, fields, options);
                 if (!dstPropResult)
                 {
                     return dstPropResult;

Luticate2.Auth/Utils/Interfaces/ILuObjectConverter.cs

 
     public interface ILuObjectConverter
     {
-        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options);
+        // TODO add dstObject
+        LuResult<object> Convert(object srcObj, LuFieldDbo path, LuPartialFieldsDbo fields, ILuObjectConverterOptions options);
     }
 
     public interface ILuObjectConverter<TTypeFrom, TTypeTo> : ILuObjectConverter