stuff

.idea/.idea.luticate2/.idea/contentModel.xml

@@ -8,11 +8,69 @@
     <e p="$PROJECT_DIR$" t="IncludeFlat">
       <e p="Auth" t="Include" />
       <e p="Luticate2.Auth" t="IncludeRecursive">
-        <e p="Business" t="Include" />
-        <e p="Class1.cs" t="Include" />
+        <e p="Business" t="Include">
+          <e p="Auth" t="Include">
+            <e p="FieldsExpressions" t="Include">
+              <e p="LuFieldsExpressionsLuGroupDboLuGroups.cs" t="Include" />
+              <e p="LuFieldsExpressionsLuMetadataDboLuMetadata.cs" t="Include" />
+            </e>
+            <e p="LuGroupsBusiness.cs" t="Include" />
+            <e p="PartialObjectCopier" t="Include">
+              <e p="LuPOCGroupsToDbo.cs" t="Include" />
+              <e p="LuPOCGroupsToModel.cs" t="Include" />
+              <e p="LuPOCObjectsMetadataToDbo.cs" t="Include" />
+            </e>
+          </e>
+          <e p="Crud" t="Include">
+            <e p="LuEfCrudBusiness.cs" t="Include" />
+          </e>
+          <e p="Fields" t="Include">
+            <e p="LuFieldsExtensions.cs" t="Include" />
+            <e p="LuPartialFieldsParser.cs" t="Include" />
+          </e>
+          <e p="FieldsExpressions" t="Include">
+            <e p="Basic" t="Include">
+              <e p="LuFieldsExpressionsString.cs" t="Include" />
+            </e>
+            <e p="LuFieldsExpressions.cs" t="Include" />
+          </e>
+          <e p="LuExpressionUtils.cs" t="Include" />
+          <e p="Pagination" t="Include">
+            <e p="LuFilterParser.cs" t="Include" />
+            <e p="LuOrderByParser.cs" t="Include" />
+          </e>
+          <e p="PartialObjectCopier" t="Include">
+            <e p="LuPartialObjectCopier.cs" t="Include" />
+            <e p="LuPartialObjectCopierExtensions.cs" t="Include" />
+          </e>
+          <e p="Serializers" t="Include">
+            <e p="PartialJson" t="Include">
+              <e p="LuJsonSerializerExtensions.cs" t="Include" />
+              <e p="LuPartialJsonWriter.cs" t="Include" />
+              <e p="LuSerializerContext.cs" t="Include" />
+            </e>
+          </e>
+        </e>
+        <e p="DataAccess" t="Include">
+          <e p="Luticate2DbContext.cs" t="Include" />
+          <e p="Models" t="Include">
+            <e p="LuGroups.cs" t="Include" />
+            <e p="LuGroupsObjects.cs" t="Include" />
+            <e p="LuObjectsMetadata.cs" t="Include" />
+            <e p="LuUsers.cs" t="Include" />
+            <e p="TestTable.cs" t="Include" />
+            <e p="luticate2Context.cs" t="Include" />
+          </e>
+        </e>
         <e p="Dbo" t="Include">
-          <e p="Basic" t="Include">
-            <e p="LuAuthOptions.cs" t="Include" />
+          <e p="Auth" t="Include">
+            <e p="LuGroupDbo.cs" t="Include" />
+            <e p="LuObjectDbo.cs" t="Include" />
+            <e p="LuObjectsMetadataDbo.cs" t="Include" />
+          </e>
+          <e p="Fields" t="Include">
+            <e p="LuFieldDbo.cs" t="Include" />
+            <e p="LuPartialFieldsDbo.cs" t="Include" />
           </e>
           <e p="LuDboExtensions.cs" t="Include" />
           <e p="Pagination" t="Include">
@@ -22,6 +80,9 @@
             <e p="LuPaginatedDbo.cs" t="Include" />
             <e p="LuPaginatedParamsDbo.cs" t="Include" />
           </e>
+          <e p="PartialObjectCopier" t="Include">
+            <e p="LuPartialObjectCopierOptions.cs" t="Include" />
+          </e>
           <e p="Result" t="Include">
             <e p="LuResult.cs" t="Include" />
             <e p="LuStatus.cs" t="Include" />
@@ -31,36 +92,58 @@
           <e p="LuExceptionsExtensions.cs" t="Include" />
           <e p="LuResultException.cs" t="Include" />
         </e>
-        <e p="Interfaces" t="Include" />
+        <e p="Interfaces" t="Include">
+          <e p="ILuCrud.cs" t="Include" />
+          <e p="ILuFieldsExpressions.cs" t="Include" />
+          <e p="ILuOrderByObjectType.cs" t="Include" />
+          <e p="ILuPartialObjectCopier.cs" t="Include" />
+        </e>
         <e p="Luticate2.Auth.csproj" t="IncludeRecursive" />
         <e p="bin" t="ExcludeRecursive" />
         <e p="obj" t="ExcludeRecursive">
           <e p="Debug" t="Include">
-            <e p="netstandard2.0" t="Include">
+            <e p="netcoreapp2.1" t="Include">
               <e p="Luticate2.Auth.AssemblyInfo.cs" t="Include" />
             </e>
           </e>
         </e>
       </e>
       <e p="Luticate2.Auth.ConsoleSample" t="IncludeRecursive">
+        <e p="Commands" t="Include">
+          <e p="CreateCommand.cs" t="Include" />
+          <e p="ListCommand.cs" t="Include" />
+        </e>
+        <e p="LuExtenstions.cs" t="Include" />
         <e p="Luticate2.Auth.ConsoleSample.csproj" t="IncludeRecursive" />
         <e p="Program.cs" t="Include" />
         <e p="bin" t="ExcludeRecursive" />
         <e p="obj" t="ExcludeRecursive">
           <e p="Debug" t="Include">
-            <e p="netcoreapp2.0" t="Include">
+            <e p="netcoreapp2.1" t="Include">
               <e p="Luticate2.Auth.ConsoleSample.AssemblyInfo.cs" t="Include" />
             </e>
           </e>
         </e>
       </e>
       <e p="Luticate2.Auth.Tests" t="IncludeRecursive">
+        <e p="Business" t="Include">
+          <e p="Fields" t="Include">
+            <e p="LuFieldDboTests.cs" t="Include" />
+          </e>
+          <e p="FieldsExpressions" t="Include">
+            <e p="LuFieldsExpressionsTests.cs" t="Include" />
+          </e>
+          <e p="LuExpressionUtilsTests.cs" t="Include" />
+          <e p="Pagination" t="Include">
+            <e p="LuFilterTests.cs" t="Include" />
+          </e>
+        </e>
         <e p="Luticate2.Auth.Tests.csproj" t="IncludeRecursive" />
-        <e p="UnitTest1.cs" t="Include" />
+        <e p="RandomTests.cs" t="Include" />
         <e p="bin" t="ExcludeRecursive" />
         <e p="obj" t="ExcludeRecursive">
           <e p="Debug" t="Include">
-            <e p="netcoreapp2.0" t="Include">
+            <e p="netcoreapp2.1" t="Include">
               <e p="Luticate2.Auth.Tests.AssemblyInfo.cs" t="Include" />
               <e p="Luticate2.Auth.Tests.Program.cs" t="Include" />
             </e>
@@ -73,7 +156,7 @@
         <e p="bin" t="ExcludeRecursive" />
         <e p="obj" t="ExcludeRecursive">
           <e p="Debug" t="Include">
-            <e p="netstandard2.0" t="Include">
+            <e p="netcoreapp2.0" t="Include">
               <e p="Luticate2.Mvc.Auth.AssemblyInfo.cs" t="Include" />
             </e>
           </e>

Luticate2.Auth.ConsoleSample/Commands/CreateCommand.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Luticate2.Auth.Business.Auth;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.Serializers.PartialJson;
+using Luticate2.Auth.Dbo.Auth;
+using Microsoft.Extensions.DependencyInjection;
+using NClap.Metadata;
+using Newtonsoft.Json;
+
+namespace Luticate2.Auth.ConsoleSample.Commands
+{
+    public class CreateCommand : Command
+    {
+        [PositionalArgument(ArgumentFlags.Required, Position = 0, Description = "Items type to create")]
+        public string ItemType { get; set; }
+
+        [PositionalArgument(ArgumentFlags.Required, Position = 1, Description = "Items to create")]
+        public string Items { get; set; }
+
+        [NamedArgument(DefaultValue = "*")]
+        public string PartialResponse { get; set; }
+
+        [NamedArgument(DefaultValue = "*")]
+        public string PartialInput { get; set; }
+
+        [NamedArgument(DefaultValue = "specific")]
+        public string OutputType { get; set; }
+
+        public override Task<CommandResult> ExecuteAsync(CancellationToken cancel)
+        {
+            var partialResponseResult = LuPartialFieldsParser.Parse(PartialResponse);
+            if (!partialResponseResult)
+            {
+                partialResponseResult.WriteLineError();
+                return Task.FromResult(CommandResult.UsageError);
+            }
+            var partialResponse = partialResponseResult.Data;
+
+            var partialInputResult = LuPartialFieldsParser.Parse(PartialInput);
+            if (!partialInputResult)
+            {
+                partialInputResult.WriteLineError();
+                return Task.FromResult(CommandResult.UsageError);
+            }
+            var partialInput = partialInputResult.Data;
+
+            var business = Program.ServiceProvider.GetService<LuGroupsBusiness>();
+
+            var items = JsonConvert.DeserializeObject<IList<LuGroupDbo>>(Items);
+
+            var results = business.Create(partialResponse, partialInput, items);
+
+            if (results)
+            {
+                var jsonSettings = new JsonSerializerSettings
+                {
+                    Formatting = Formatting.None
+                };
+                foreach (var item in results.Data)
+                {
+                    if (OutputType == "specific")
+                    {
+                        Console.WriteLine($"{item.Id} {item.Name ?? "??"}");
+                    }
+                    else if (OutputType == "json-full")
+                    {
+                        Console.WriteLine(JsonConvert.SerializeObject(item, jsonSettings));
+                    }
+                    else if (OutputType == "json-partial")
+                    {
+                        Console.WriteLine(LuPartialJsonWriter.SerializeObject(item, partialResponse, jsonSettings));
+                    }
+                }
+            }
+            else
+            {
+                results.WriteLineError();
+                return Task.FromResult(CommandResult.RuntimeFailure);
+            }
+
+            return base.ExecuteAsync(cancel);
+        }
+    }
+}

Luticate2.Auth.ConsoleSample/Commands/ListCommand.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Luticate2.Auth.Business.Auth;
+using Luticate2.Auth.Business.Pagination;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.Serializers.PartialJson;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Pagination;
+using Microsoft.Extensions.DependencyInjection;
+using NClap.Metadata;
+using Newtonsoft.Json;
+
+namespace Luticate2.Auth.ConsoleSample.Commands
+{
+    public class ListCommand : Command
+    {
+        [PositionalArgument(ArgumentFlags.Optional, Position = 0, Description = "Items type to list")]
+        public string ItemType { get; set; }
+
+        [NamedArgument(DefaultValue = "*")]
+        public string PartialResponse { get; set; }
+
+        [NamedArgument(DefaultValue = "")]
+        public string Filter { get; set; }
+
+        [NamedArgument(DefaultValue = "id:asc")]
+        public string OrderBy { get; set; }
+
+        [NamedArgument(DefaultValue = "0")]
+        public int Page { get; set; }
+
+        [NamedArgument(DefaultValue = "10")]
+        public int PerPage { get; set; }
+
+        [NamedArgument(DefaultValue = "specific")]
+        public string OutputType { get; set; }
+
+        public override Task<CommandResult> ExecuteAsync(CancellationToken cancel)
+        {
+            if (ItemType == null)
+            {
+                Console.WriteLine("groups");
+            }
+            else
+            {
+                var partialResponseResult = LuPartialFieldsParser.Parse(PartialResponse);
+                if (!partialResponseResult)
+                {
+                    partialResponseResult.WriteLineError();
+                    return Task.FromResult(CommandResult.UsageError);
+                }
+                var partialResponse = partialResponseResult.Data;
+
+                var filterResult = LuFilterParser.Parse<LuGroups>(Filter);
+                if (!filterResult)
+                {
+                    filterResult.WriteLineError();
+                    return Task.FromResult(CommandResult.UsageError);
+                }
+                var filter = filterResult.Data;
+
+                var orderByResult = LuOrderByParser.Parse(OrderBy);
+                if (!orderByResult)
+                {
+                    orderByResult.WriteLineError();
+                    return Task.FromResult(CommandResult.UsageError);
+                }
+                var orderBy = orderByResult.Data;
+
+                var business = Program.ServiceProvider.GetService<LuGroupsBusiness>();
+                var stopWatch = Stopwatch.StartNew();
+                var results = business.Read(partialResponse, new LuPaginatedParamsDbo
+                {
+                    Filter = filter,
+                    OrderBy = orderBy,
+                    Page = Page,
+                    PerPage = PerPage
+                });
+                var elapsed = stopWatch.ElapsedMilliseconds;
+                if (results)
+                {
+                    var jsonSettings = new JsonSerializerSettings
+                    {
+                        Formatting = Formatting.None
+                    };
+                    Console.WriteLine($"Displaying {Page * PerPage + 1}-{(Page + 1) * PerPage} of {results.Data.Count} ({elapsed} ms)");
+                    foreach (var item in results.Data.Data)
+                    {
+                        if (OutputType == "specific")
+                        {
+                            Console.WriteLine($"{item.Id} {item.Name ?? "??"}");
+                        }
+                        else if (OutputType == "json-full")
+                        {
+                            Console.WriteLine(JsonConvert.SerializeObject(item, jsonSettings));
+                        }
+                        else if (OutputType == "json-partial")
+                        {
+                            Console.WriteLine(LuPartialJsonWriter.SerializeObject(item, partialResponse, jsonSettings));
+                        }
+                    }
+                }
+                else
+                {
+                    results.WriteLineError();
+                    return Task.FromResult(CommandResult.RuntimeFailure);
+                }
+            }
+
+            return Task.FromResult(CommandResult.Success);
+        }
+    }
+}

Luticate2.Auth.ConsoleSample/LuExtenstions.cs

@@ -0,0 +1,13 @@
+using System;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.ConsoleSample
+{
+    public static class LuExtenstions
+    {
+        public static void WriteLineError<T>(this LuResult<T> result)
+        {
+            Console.WriteLine($"Error: {result.PublicDetails}\nPrivateDetails: {result.PrivateDetails}\nException: {result.Exception}");
+        }
+    }
+}

Luticate2.Auth.ConsoleSample/Luticate2.Auth.ConsoleSample.csproj

@@ -1,9 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Luticate2.Auth\Luticate2.Auth.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="NClap" Version="2.3.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+      <HintPath>..\..\..\..\.nuget\packages\newtonsoft.json\10.0.1\lib\netstandard1.3\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+  </ItemGroup>
 </Project>

Luticate2.Auth.ConsoleSample/Program.cs

@@ -1,12 +1,80 @@
 using System;
+using Luticate2.Auth.Business.Auth;
+using Luticate2.Auth.Business.Auth.FieldsExpressions;
+using Luticate2.Auth.Business.Auth.PartialObjectCopier;
+using Luticate2.Auth.Business.FieldsExpressions;
+using Luticate2.Auth.Business.FieldsExpressions.Basic;
+//using Luticate2.Auth.Business.Pagination.OrderBy;
+//using Luticate2.Auth.Business.Pagination.OrderBy.Basic;
+using Luticate2.Auth.Business.PartialObjectCopier;
+using Luticate2.Auth.ConsoleSample.Commands;
+using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using NClap.Metadata;
+using NClap.Repl;
 
 namespace Luticate2.Auth.ConsoleSample
 {
+    enum CommandsEnum
+    {
+        [Command(typeof(ListCommand), Description = "Lists Luticate2 items", LongName = "ls", ShortName = "l")]
+        ListItems,
+
+        [Command(typeof(CreateCommand), Description = "Creates Luticate2 items", LongName = "create", ShortName = "c")]
+        CreateItems,
+
+        [Command(typeof(ExitCommand), Description = "Exits the shell")]
+        Exit
+    }
+    
     class Program
     {
+        public static IServiceProvider ServiceProvider;
+        
         static void Main(string[] args)
         {
-            Console.WriteLine(Class1.Method1("Hello World!"));
+            IServiceCollection services = new ServiceCollection();
+            
+            services.AddScoped<LuGroupsBusiness>();
+
+            services.AddSingleton<ILuPartialObjectCopier<LuObjectsMetadata, LuObjectsMetadataDbo>, LuPOCObjectsMetadataToDbo>();
+            services.AddSingleton<ILuPartialObjectCopier<LuGroups, LuGroupDbo>, LuPOCGroupsToDbo>();
+            services.AddSingleton<ILuPartialObjectCopier<LuGroupDbo, LuGroups>, LuPOCGroupsToModel>();
+
+
+            services.AddSingleton<ILuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>, LuFieldsExpressionsLuMetadataDboLuMetadata>();
+            services.AddSingleton<ILuFieldsExpressions<LuGroupDbo, LuGroups>, LuFieldsExpressionsLuGroupDboLuGroups>();
+
+            services.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
+            services.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
+            services.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();
+
+            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTime>, LuFieldsExpressions<DateTime, DateTime>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTimeOffset>, LuFieldsExpressions<DateTimeOffset, DateTimeOffset>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTime, DateTimeOffset>, LuFieldsExpressions<DateTime, DateTimeOffset>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset, DateTime>, LuFieldsExpressions<DateTimeOffset, DateTime>>();
+
+            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTime?>, LuFieldsExpressions<DateTime?, DateTime?>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>, LuFieldsExpressions<DateTimeOffset?, DateTimeOffset?>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTime?, DateTimeOffset?>, LuFieldsExpressions<DateTime?, DateTimeOffset?>>();
+            services.AddSingleton<ILuFieldsExpressions<DateTimeOffset?, DateTime?>, LuFieldsExpressions<DateTimeOffset?, DateTime?>>();
+
+            services.AddDbContext<Luticate2DbContext>(options =>
+            {
+                options.UseNpgsql(@"Host=localhost;Database=luticate2;Username=dev;Password=dev");
+                options.UseInternalServiceProvider(new ServiceCollection()
+                    .AddEntityFrameworkNpgsql()
+                    .BuildServiceProvider());
+            }, ServiceLifetime.Transient);
+
+            ServiceProvider = services.BuildServiceProvider();
+            
+            var loop = new Loop(typeof(CommandsEnum));
+            loop.Execute();
         }
     }
 }

Luticate2.Auth.Tests/Business/Fields/LuFieldDboTests.cs

@@ -0,0 +1,61 @@
+using System.Linq;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Dbo.Fields;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.Fields
+{
+    public class LuFieldDboTests
+    {
+        public class TestDbo1
+        {
+            public string MyString { get; set; }
+        }
+        
+        [Fact]
+        public void TestMake1()
+        {
+            var field1 = LuFieldDbo.Make<TestDbo1>(x => x.MyString.Length);
+            Assert.True(field1.Parts.SequenceEqual(new[] {"MyString", "Length"}));
+        }
+        
+        [Fact]
+        public void TestMake2()
+        {
+            var field1 = LuFieldDbo.Make(new[] {"MyString", "Length"});
+            Assert.True(field1.Parts.SequenceEqual(new[] {"MyString", "Length"}));
+        }
+        
+        [Fact]
+        public void TestMake3()
+        {
+            var field1 = LuFieldDbo.Make("MyString.Length");
+            Assert.True(field1.Parts.SequenceEqual(new[] {"MyString", "Length"}));
+        }
+        
+        [Fact]
+        public void TestMake4()
+        {
+            var field1 = LuFieldDbo.Make("MyString/Length");
+            Assert.True(field1.Parts.SequenceEqual(new[] {"MyString", "Length"}));
+        }
+
+        [Fact]
+        public void TestPop1()
+        {
+            var field1 = LuFieldDbo.Make<TestDbo1>(x => x.MyString.Length);
+            var field2 = field1.Pop();
+            Assert.True(field1.Parts.SequenceEqual(new[] {"Length"}));
+            Assert.True(field2.Parts.SequenceEqual(new[] {"Length"}));
+        }
+
+        [Fact]
+        public void TestPopped1()
+        {
+            var field1 = LuFieldDbo.Make<TestDbo1>(x => x.MyString.Length);
+            var field2 = field1.Popped();
+            Assert.True(field1.Parts.SequenceEqual(new[] {"MyString", "Length"}));
+            Assert.True(field2.Parts.SequenceEqual(new[] {"Length"}));
+        }
+    }
+}

Luticate2.Auth.Tests/Business/FieldsExpressions/LuFieldsExpressionsTests.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.FieldsExpressions;
+using Luticate2.Auth.Business.FieldsExpressions.Basic;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.FieldsExpressions
+{
+    public class LuFieldsExpressionsTestDbo1TestModel1 : LuFieldsExpressions<TestDbo1, TestModel1>
+    {
+        public LuFieldsExpressionsTestDbo1TestModel1(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, TestModel1>> modelProperty, LuFieldDbo field)
+        {
+            if (field.StartsWith<TestDbo1>(x => x.MyInt))
+            {
+                return GetSubField<TType1, int, int>(modelProperty, field, x => x.MyInt);
+            }
+            else if (field.StartsWith<TestDbo1>(x => x.Metadata))
+            {
+                return GetSubField<TType1, MetadataDbo, MetadataModel>(modelProperty, field, x => x.MetadataModel);
+            }
+
+            return base.GetExpressionInternal(modelProperty, field);
+        }
+    }
+
+    public class LuFieldsExpressionsMetadataDboMetadataModel : LuFieldsExpressions<MetadataDbo, MetadataModel>
+    {
+        public LuFieldsExpressionsMetadataDboMetadataModel(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, MetadataModel>> modelProperty, LuFieldDbo field)
+        {
+            if (field.StartsWith<MetadataDbo>(x => x.Id))
+            {
+                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
+            }
+
+            return base.GetExpressionInternal(modelProperty, field);
+        }
+    }
+    
+    public class TestDbo1
+    {
+        public string MyString { get; set; }
+
+        public int MyInt { get; set; }
+
+        public MetadataDbo Metadata { get; set; }
+    }
+
+    public class MetadataDbo
+    {
+        public Guid Id { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+    }
+    
+    public class TestModel1
+    {
+        public string MyString { get; set; }
+
+        public int MyInt { get; set; }
+
+        public MetadataModel MetadataModel { get; set; }
+    }
+
+    public class MetadataModel
+    {
+        public Guid Id { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+    }
+    
+    public class LuFieldsExpressionsTests
+    {
+        public IServiceProvider GetServiceProvider()
+        {
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection.AddSingleton<ILuFieldsExpressions<TestDbo1, TestModel1>, LuFieldsExpressionsTestDbo1TestModel1>();
+            serviceCollection.AddSingleton<ILuFieldsExpressions<MetadataDbo, MetadataModel>, LuFieldsExpressionsMetadataDboMetadataModel>();
+            serviceCollection.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
+            serviceCollection.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
+            serviceCollection.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();
+
+            var serviceProvider = serviceCollection.BuildServiceProvider();
+            return serviceProvider;
+        }
+        
+        [Fact]
+        public void Test1()
+        {
+            var serviceProvider = GetServiceProvider();
+            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
+            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id"));
+            Assert.Equal(LuStatus.Success.ToInt(), exprResult.Status);
+            Assert.NotNull(exprResult.Data);
+            var operand = LuExpressionUtils.GetFromConvert(exprResult.Data);
+            var str = operand.ToString();
+            Assert.Equal("x.MetadataModel.Id", str);
+        }
+
+        [Fact]
+        public void TestError1()
+        {
+            var serviceProvider = GetServiceProvider();
+            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
+            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id.NxField"));
+            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
+            Assert.Null(exprResult.Data);
+        }
+
+        [Fact]
+        public void TestError2()
+        {
+            var serviceProvider = GetServiceProvider();
+            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
+            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.*"));
+            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
+            Assert.Null(exprResult.Data);
+        }
+    }
+}

Luticate2.Auth.Tests/Business/LuExpressionUtilsTests.cs

@@ -0,0 +1,119 @@
+using System.Linq;
+using Luticate2.Auth.Business;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business
+{
+    public class TestDbo1
+    {
+        public string MyString { get; set; }
+
+        public TestDbo2 TestDbo2 { get; set; }
+    }
+
+    public class TestDbo2
+    {
+        public string MyOtherString { get; set; }
+        
+        public int MyInt { get; set; }
+
+        public TestDbo2 RecursiveObject { get; set; }
+    }
+
+    public class LuExpressionUtilsTests
+    {
+        [Fact]
+        public void GetSingleMemberFromExpression1()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, string>(x => x.MyString);
+            Assert.NotNull(memberInfo);
+            Assert.Equal("MyString", memberInfo.Name);
+        }
+        
+        [Fact]
+        public void GetSingleMemberFromExpression2()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, TestDbo2>(x => x.TestDbo2);
+            Assert.NotNull(memberInfo);
+            Assert.Equal("TestDbo2", memberInfo.Name);
+        }
+        
+        [Fact]
+        public void GetSingleMemberFromExpression3()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, TestDbo1>(x => x);
+            Assert.Null(memberInfo);
+        }
+        
+        [Fact]
+        public void GetSingleMemberFromExpression4()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => 42);
+            Assert.Null(memberInfo);
+        }
+        
+        [Fact]
+        public void GetSingleMemberFromExpression5()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => x.TestDbo2.MyInt);
+            Assert.Null(memberInfo);
+        }
+        
+        [Fact]
+        public void GetSingleMemberFromExpression6()
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression<TestDbo1, int>(x => x.TestDbo2.RecursiveObject.MyInt);
+            Assert.Null(memberInfo);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression1()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, string>(x => x.MyString);
+            Assert.NotNull(memberInfo);
+            var memberInfosString = string.Join(".", memberInfo.Select(x => x.Name));
+            Assert.Equal("MyString", memberInfosString);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression2()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, TestDbo2>(x => x.TestDbo2);
+            Assert.NotNull(memberInfo);
+            var memberInfosString = string.Join(".", memberInfo.Select(x => x.Name));
+            Assert.Equal("TestDbo2", memberInfosString);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression3()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, TestDbo1>(x => x);
+            Assert.Null(memberInfo);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression4()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, int>(x => 42);
+            Assert.Null(memberInfo);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression5()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, int>(x => x.TestDbo2.MyInt);
+            Assert.NotNull(memberInfo);
+            var memberInfosString = string.Join(".", memberInfo.Select(x => x.Name));
+            Assert.Equal("TestDbo2.MyInt", memberInfosString);
+        }
+
+        [Fact]
+        public void GetMembersFromExpression6()
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression<TestDbo1, int>(x => x.TestDbo2.RecursiveObject.MyInt);
+            Assert.NotNull(memberInfo);
+            var memberInfosString = string.Join(".", memberInfo.Select(x => x.Name));
+            Assert.Equal("TestDbo2.RecursiveObject.MyInt", memberInfosString);
+        }
+    }
+}

Luticate2.Auth.Tests/Business/Pagination/LuFilterTests.cs

@@ -0,0 +1,19 @@
+using Luticate2.Auth.Business.Pagination;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Result;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.Pagination
+{
+    public class LuFilterTests
+    {
+        [Fact]
+        public void Test1()
+        {
+            var filterResult = LuFilterParser.Parse<LuGroupDbo>("x.Name.Contains(\"test\")");
+            Assert.Equal(LuStatus.Success.ToInt(), filterResult.Status);
+            Assert.NotNull(filterResult.Data);
+        }
+    }
+}

Luticate2.Auth.Tests/Luticate2.Auth.Tests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>

Luticate2.Auth.Tests/RandomTests.cs

@@ -0,0 +1,41 @@
+using System.Linq;
+using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.DataAccess.Models;
+using Microsoft.EntityFrameworkCore;
+using Xunit;
+
+namespace Luticate2.Auth.Tests
+{
+    public class RandomTests
+    {
+        [Fact]
+        public void Test1()
+        {
+            var dbContext = new luticate2Context();
+            var items = dbContext.LuGroups.Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
+            var list = items.ToList();
+            Assert.NotNull(list);
+            Assert.Equal(1, list.Count);
+        }
+
+        [Fact]
+        public void Test2()
+        {
+            var dbContext = new luticate2Context();
+            var items = dbContext.LuGroups.OrderBy(x => x.Id).Where(groups => groups.LuGroupsObjects.Any(x => x.Priority == 0));
+            var list = items.ToList();
+            Assert.NotNull(list);
+            Assert.Equal(1, list.Count);
+        }
+
+        [Fact]
+        public void Test3()
+        {
+            var dbContext = new luticate2Context();
+            var items = dbContext.LuGroups.OrderBy(x => x.Id);
+            var list = items.ToList();
+            Assert.NotNull(list);
+            Assert.Equal(2, list.Count);
+        }
+    }
+}

Luticate2.Auth.Tests/UnitTest1.cs

@@ -1,16 +0,0 @@
-using System;
-using Xunit;
-
-namespace Luticate2.Auth.Tests
-{
-    public class UnitTest1
-    {
-        [Fact]
-        public void Test1()
-        {
-            string expected = "testValue 0";
-            string actual = Class1.Method1("0");
-            Assert.Equal(expected, actual);
-        }
-    }
-}

Luticate2.Auth/Business/Auth/FieldsExpressions/LuFieldsExpressionsLuGroupDboLuGroups.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.FieldsExpressions;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Auth.FieldsExpressions
+{
+    public class LuFieldsExpressionsLuGroupDboLuGroups : LuFieldsExpressions<LuGroupDbo, LuGroups>
+    {
+        public LuFieldsExpressionsLuGroupDboLuGroups(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(
+            Expression<Func<TType1, LuGroups>> modelProperty, LuFieldDbo field)
+        {
+            if (field.StartsWith<LuGroupDbo>(x => x.Id))
+            {
+                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
+            }
+            else if (field.StartsWith<LuGroupDbo>(x => x.Name))
+            {
+                return GetSubField<TType1, string, string>(modelProperty, field, x => x.Name);
+            }
+            else if (field.StartsWith<LuGroupDbo>(x => x.Metadata))
+            {
+                return GetSubField<TType1, LuObjectsMetadataDbo, LuObjectsMetadata>(modelProperty, field, x => x.IdNavigation);
+            }
+
+            return base.GetExpressionInternal(modelProperty, field);
+        }
+    }
+}

Luticate2.Auth/Business/Auth/FieldsExpressions/LuFieldsExpressionsLuMetadataDboLuMetadata.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Business.FieldsExpressions;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Auth.FieldsExpressions
+{
+    public class LuFieldsExpressionsLuMetadataDboLuMetadata : LuFieldsExpressions<LuObjectsMetadataDbo, LuObjectsMetadata>
+    {
+        public LuFieldsExpressionsLuMetadataDboLuMetadata(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, LuObjectsMetadata>> modelProperty, LuFieldDbo field)
+        {
+            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.Id))
+            {
+                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
+            }
+            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.CreatedAt))
+            {
+                return GetSubField<TType1, DateTime, DateTimeOffset>(modelProperty, field, x => x.CreatedAt);
+            }
+            if (field.StartsWith<LuObjectsMetadataDbo>(x => x.UpdatedAt))
+            {
+                return GetSubField<TType1, DateTime?, DateTimeOffset?>(modelProperty, field, x => x.UpdatedAt);
+            }
+
+            return base.GetExpressionInternal(modelProperty, field);
+        }
+    }
+}

Luticate2.Auth/Business/Auth/LuGroupsBusiness.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using Luticate2.Auth.Business.Crud;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.Result;
+using Microsoft.EntityFrameworkCore;
+
+namespace Luticate2.Auth.Business.Auth
+{
+    public class LuGroupsBusiness : LuEfCrudBusiness<LuGroupDbo, LuGroups, Luticate2DbContext>
+    {
+        public LuGroupsBusiness(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<IQueryable<LuGroups>> Include(LuPartialFieldsDbo partialResponse, IQueryable<LuGroups> queryable)
+        {
+            var included = queryable;
+            if (partialResponse.Fields.IsIncluded<LuGroupDbo>(x => x.Metadata))
+            {
+                included = included.Include(x => x.IdNavigation);
+            }
+
+            return LuResult<IQueryable<LuGroups>>.Ok(included);
+        }
+
+//        protected override LuResult<IQueryable<LuGroups>> Filter(LuFilterDbo filter, IQueryable<LuGroups> queryable)
+//        {
+//            return LuResult<IQueryable<LuGroups>>.Ok(queryable.Where(groups => groups.LuGroupsObjects.Any(objects => objects.Priority == 0)));
+//        }
+
+        public override LuResult<IList<LuGroupDbo>> Create(LuPartialFieldsDbo partialResponse,
+            LuPartialFieldsDbo partialInput, IEnumerable<LuGroupDbo> dbos)
+        {
+            var addedDbos = new List<LuGroupDbo>();
+            var addedModels = new List<LuGroups>();
+            var createResult = Execute((context, set) =>
+            {
+                foreach (var dbo in dbos)
+                {
+                    var model = new LuGroups();
+                    var addResult = ConvertDboToModel(partialInput, dbo, model);
+                    if (!addResult)
+                    {
+                        return addResult.To<bool>();
+                    }
+                    model.IdNavigation = new LuObjectsMetadata();
+                    set.Add(model);
+                    addedModels.Add(model);
+                }
+
+                context.SaveChanges();
+
+                return LuResult<bool>.Ok(true);
+            });
+
+            if (!createResult)
+            {
+                return createResult.To<IList<LuGroupDbo>>();
+            }
+
+            var ids = addedModels.Select(x => x.Id);
+
+            foreach (var addedModel in addedModels)
+            {
+                var addedDbo = new LuGroupDbo();
+                var convertResult = ConvertModelToDbo(partialResponse, addedModel, addedDbo);
+                if (!convertResult)
+                {
+                    return convertResult.To<IList<LuGroupDbo>>();
+                }
+                addedDbos.Add(addedDbo);
+            }
+
+            return LuResult<IList<LuGroupDbo>>.Ok(addedDbos);
+        }
+    }
+}

Luticate2.Auth/Business/Auth/PartialObjectCopier/LuPOCGroupsToDbo.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Linq;
+using Luticate2.Auth.Business.PartialObjectCopier;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Auth.PartialObjectCopier
+{
+    public class LuPOCGroupsToDbo : LuPartialObjectCopier<LuGroups, LuGroupDbo>
+    {
+        public LuPOCGroupsToDbo(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        public override LuResult<LuGroupDbo> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, LuGroups modelFrom,
+            LuGroupDbo dboTo, LuPartialObjectCopierOptions options)
+        {
+            MayCopy(path, fields, dboTo, dbo => dbo.Id, () => modelFrom.Id);
+            MayCopySubProperty(path, fields, modelFrom, dboTo, x => x.IdNavigation, x => x.Metadata, options);
+            MayCopy(path, fields, dboTo, dbo => dbo.Name, () => modelFrom.Name);
+
+            return LuResult<LuGroupDbo>.Ok(dboTo);
+        }
+    }
+}

Luticate2.Auth/Business/Auth/PartialObjectCopier/LuPOCGroupsToModel.cs

@@ -0,0 +1,26 @@
+using System;
+using Luticate2.Auth.Business.PartialObjectCopier;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Auth.PartialObjectCopier
+{
+    public class LuPOCGroupsToModel : LuPartialObjectCopier<LuGroupDbo, LuGroups>
+    {
+        public LuPOCGroupsToModel(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        public override LuResult<LuGroups> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, LuGroupDbo dboFrom, LuGroups modelTo,
+            LuPartialObjectCopierOptions options)
+        {
+            MayCopy(path, fields, modelTo, model => model.Id, () => dboFrom.Id);
+            MayCopy(path, fields, modelTo, model => model.Name, () => dboFrom.Name);
+
+            return LuResult<LuGroups>.Ok(modelTo);
+        }
+    }
+}

Luticate2.Auth/Business/Auth/PartialObjectCopier/LuPOCObjectsMetadataToDbo.cs

@@ -0,0 +1,27 @@
+using System;
+using Luticate2.Auth.Business.PartialObjectCopier;
+using Luticate2.Auth.DataAccess.Models;
+using Luticate2.Auth.Dbo.Auth;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Auth.PartialObjectCopier
+{
+    public class LuPOCObjectsMetadataToDbo : LuPartialObjectCopier<LuObjectsMetadata, LuObjectsMetadataDbo>
+    {
+        public LuPOCObjectsMetadataToDbo(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        public override LuResult<LuObjectsMetadataDbo> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, LuObjectsMetadata modelFrom, LuObjectsMetadataDbo dboTo,
+            LuPartialObjectCopierOptions options)
+        {
+            MayCopy(path, fields, dboTo, dbo => dbo.Id, () => modelFrom.Id);
+            MayCopy(path, fields, dboTo, dbo => dbo.CreatedAt, () => modelFrom.CreatedAt);
+            MayCopy(path, fields, dboTo, dbo => dbo.UpdatedAt, () => modelFrom.UpdatedAt);
+
+            return LuResult<LuObjectsMetadataDbo>.Ok(dboTo);
+        }
+    }
+}

Luticate2.Auth/Business/Crud/LuEfCrudBusiness.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Luticate2.Auth.Business.Crud
+{
+    public class LuEfCrudBusiness<TDbo, TModel, TDbContext> : ILuCrud<TDbo>
+        where TModel : class
+        where TDbContext : DbContext
+        where TDbo : new()
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        public LuEfCrudBusiness(IServiceProvider serviceProvider)
+        {
+            ServiceProvider = serviceProvider;
+        }
+
+        protected virtual LuResult<TModel> ConvertDboToModel(LuPartialFieldsDbo partialInput, TDbo dbo, TModel model)
+        {
+            var copier = ServiceProvider.GetService<ILuPartialObjectCopier<TDbo, TModel>>();
+            if (copier == null)
+            {
+                return LuResult<TModel>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuPartialObjectCopier<{typeof(TDbo).Name}, {typeof(TModel).Name}>");
+            }
+            var result = copier.Copy(partialInput, dbo, model, new LuPartialObjectCopierOptions());
+            return result;
+        }
+
+        protected virtual LuResult<TDbo> ConvertModelToDbo(LuPartialFieldsDbo partialResponse, TModel model, TDbo dbo)
+        {
+            var copier = ServiceProvider.GetService<ILuPartialObjectCopier<TModel, TDbo>>();
+            if (copier == null)
+            {
+                return LuResult<TDbo>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuPartialObjectCopier<{typeof(TModel).Name}, {typeof(TDbo).Name}>");
+            }
+            var result = copier.Copy(partialResponse, model, dbo, new LuPartialObjectCopierOptions());
+            return result;
+        }
+
+        protected virtual LuResult<T> HandleError<T>(Exception e)
+        {
+            return LuResult<T>.Error(LuStatus.DbError.ToInt(), e);
+        }
+
+        protected LuResult<T> Execute<T>(Func<TDbContext, DbSet<TModel>, LuResult<T>> action)
+        {
+            try
+            {
+                using (var db = ServiceProvider.GetService<TDbContext>())
+                {
+                    return action(db, db.Set<TModel>());
+                }
+            }
+            catch (Exception e)
+            {
+                var result = HandleError<T>(e);
+                return result;
+            }
+        }
+
+        protected virtual LuResult<IQueryable<TModel>> Include(LuPartialFieldsDbo partialResponse, IQueryable<TModel> queryable)
+        {
+            return LuResult<IQueryable<TModel>>.Ok(queryable);
+        }
+
+        protected virtual LuResult<IQueryable<TModel>> Filter(LuFilterDbo filter, IQueryable<TModel> queryable)
+        {
+            return LuResult<IQueryable<TModel>>.Ok(queryable.Where((Expression<Func<TModel, bool>>) filter.Expression));
+        }
+
+        protected IQueryable<TModel> ConvertAndOrderByQueryable<T>(Expression<Func<TModel, object>> exp,
+            LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable, Expression expressionNoConvert)
+        {
+            var ordered = queryable as IOrderedQueryable<TModel>;
+            var expType = expressionNoConvert.Type;
+            var type = typeof(T);
+            if (type.IsAssignableFrom(expType))
+            {
+                var expLambda = Expression.Lambda<Func<TModel, T>>(expressionNoConvert, exp.Parameters);
+                if (ordered != null)
+                {
+                    ordered = orderByfield.Asc ? ordered.ThenBy(expLambda) : ordered.ThenByDescending(expLambda);
+                }
+                else
+                {
+                    ordered = orderByfield.Asc ? queryable.OrderBy(expLambda) : queryable.OrderByDescending(expLambda);
+                }
+            }
+
+            return ordered ?? queryable;
+        }
+
+        protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable)
+        {
+            var expressionBuilder = ServiceProvider.GetService<ILuFieldsExpressions<TDbo, TModel>>();
+            var expressionResult = expressionBuilder.GetExpression<TModel>(x => x, orderByfield.Field);
+            if (!expressionResult)
+            {
+                return expressionResult.To<IQueryable<TModel>>();
+            }
+
+            var expression = expressionResult.Data;
+            var expressionNoConvert = LuExpressionUtils.GetFromConvert(expression);
+
+            var ordered = ConvertAndOrderByQueryable<bool>(expression, orderByfield, queryable, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<byte>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<DateTime>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<DateTimeOffset>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<decimal>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<double>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<float>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<Guid>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<short>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<int>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<long>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<char>(expression, orderByfield, ordered, expressionNoConvert);
+            ordered = ConvertAndOrderByQueryable<string>(expression, orderByfield, ordered, expressionNoConvert);
+            
+            return LuResult<IQueryable<TModel>>.Ok(ordered);
+        }
+
+        protected virtual LuResult<IQueryable<TModel>> OrderBy(LuOrderByDbo orderBy, IQueryable<TModel> queryable)
+        {
+            var ordered = queryable;
+            foreach (var field in orderBy.OrderByFields)
+            {
+                var orderedResult = OrderByField(field, ordered);
+                if (!orderedResult)
+                {
+                    return orderedResult.To<IQueryable<TModel>>();
+                }
+
+                ordered = orderedResult.Data;
+            }
+
+            return LuResult<IQueryable<TModel>>.Ok(ordered ?? queryable);
+        }
+
+        protected virtual LuResult<IQueryable<TModel>> Paginate(int page, int perPage, IQueryable<TModel> queryable)
+        {
+            var paginated = queryable.Skip(page * perPage).Take(perPage);
+            return LuResult<IQueryable<TModel>>.Ok(paginated);
+        }
+
+        public virtual LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual LuResult<LuPaginatedDbo<TDbo>> Read(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams)
+        {
+            var result = Execute((context, set) =>
+            {
+                var includeResult = Include(partialResponse, set);
+                if (!includeResult)
+                {
+                    return includeResult.To<LuPaginatedDbo<TDbo>>();
+                }
+
+                var included = includeResult.Data;
+
+                var orderByResult = OrderBy(paginationParams.OrderBy, included);
+                if (!orderByResult)
+                {
+                    return orderByResult.To<LuPaginatedDbo<TDbo>>();
+                }
+
+                var ordered = orderByResult.Data;
+                
+                var filteredResult = Filter(paginationParams.Filter, ordered);
+                if (!filteredResult)
+                {
+                    return filteredResult.To<LuPaginatedDbo<TDbo>>();
+                }
+
+                var filtered = filteredResult.Data;
+                var count = filtered.Count();
+
+                var paginatedResult = Paginate(paginationParams.Page, paginationParams.PerPage, filtered);
+                if (!paginatedResult)
+                {
+                    return paginatedResult.To<LuPaginatedDbo<TDbo>>();
+                }
+
+                var paginated = paginatedResult.Data;
+
+                var data = paginated.AsEnumerable().Select(model =>
+                    {
+                        var dbo = new TDbo();
+                        ConvertModelToDbo(partialResponse, model, dbo);
+                        return dbo;
+                    }).ToList();
+
+                return LuResult<LuPaginatedDbo<TDbo>>.Ok(new LuPaginatedDbo<TDbo>
+                {
+                    Count = count,
+                    Data = data
+                });
+            });
+            return result;
+        }
+
+        public virtual LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Luticate2.Auth/Business/Fields/LuFieldsExtensions.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Pagination;
+
+namespace Luticate2.Auth.Business.Fields
+{
+    public static class LuFieldsExtensions
+    {
+        public static bool IsIncluded(this IEnumerable<LuFieldDbo> fields, IEnumerable<string> parts, bool ignoreCase = true)
+        {
+            return fields.Any(x => x.IsIncluded(parts, ignoreCase));
+        }
+
+        public static bool IsIncluded(this IEnumerable<LuFieldDbo> fields, string path, bool ignoreCase = true)
+        {
+            return fields.Any(x => x.IsIncluded(path, ignoreCase));
+        }
+
+        public static bool IsIncluded(this IEnumerable<LuFieldDbo> fields, LuFieldDbo path, bool ignoreCase = true)
+        {
+            return fields.Any(x => x.IsIncluded(path, ignoreCase));
+        }
+
+        public static bool IsIncluded<TModel>(this IEnumerable<LuFieldDbo> fields, Expression<Func<TModel, object>> property, bool ignoreCase = true)
+        {
+            return fields.Any(x => x.IsIncluded(property, ignoreCase));
+        }
+
+
+        public static bool IsIncluded(this LuFieldDbo field, IEnumerable<string> parts, bool ignoreCase = true)
+        {
+            var list = parts.ToList();
+            var stringComparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+
+            for (var index = 0; index < list.Count && index < field.Parts.Count; index++)
+            {
+                if (!string.Equals(list[index], field.Parts[index], stringComparison) && field.Parts[index] != "*")
+                {
+                    return false;
+                }
+
+                // If the last part of the given value is reached and the field has more parts than the given value,
+                // there is no match, eg. the field value is foo/bar and the given value is foo. If the field parts and
+                // the given value parts have equal lengths, there is a match, eg. the field value is foo/bar and the
+                // given value is foo/bar.
+                if (index == list.Count - 1)
+                {
+                    return list.Count <= field.Parts.Count;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool IsIncluded(this LuFieldDbo field, string path, bool ignoreCase = true)
+        {
+            return field.IsIncluded(LuFieldDbo.Make(path), ignoreCase);
+        }
+
+        public static bool IsIncluded(this LuFieldDbo field, LuFieldDbo path, bool ignoreCase = true)
+        {
+            return field.IsIncluded(path.Parts, ignoreCase);
+        }
+
+        public static bool IsIncluded<TModel>(this LuFieldDbo field, Expression<Func<TModel, object>> property, bool ignoreCase = true)
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression(property);
+            var parts = memberInfo.Select(x => x.Name).ToList();
+            return field.IsIncluded(parts, ignoreCase);
+        }
+
+
+        public static bool StartsWith(this LuFieldDbo field, IEnumerable<string> subParts, bool ignoreCase = true)
+        {
+            var comparer = ignoreCase ? StringComparer.CurrentCultureIgnoreCase : StringComparer.CurrentCulture;
+            using (IEnumerator<string> enumerator = field.Parts.GetEnumerator())
+            {
+                foreach (string source in subParts)
+                {
+                    if (!enumerator.MoveNext() || comparer.Compare(enumerator.Current, source) != 0)
+                        return false;
+                }
+            }
+            return true;
+        }
+
+        public static bool StartsWith(this LuFieldDbo field, string subparts, bool ignoreCase = true)
+        {
+            return field.StartsWith(LuFieldDbo.Make(subparts), ignoreCase);
+        }
+
+        public static bool StartsWith(this LuFieldDbo field, LuFieldDbo path, bool ignoreCase = true)
+        {
+            return field.StartsWith(path.Parts, ignoreCase);
+        }
+
+        public static bool StartsWith<TDbo>(this LuFieldDbo field, Expression<Func<TDbo, object>> property, bool ignoreCase = true)
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression(property);
+            var memberInfoString = memberInfo.Select(x => x.Name).ToList();
+            return field.StartsWith(memberInfoString, ignoreCase);
+        }
+
+
+        public static bool Is(this LuFieldDbo field, IEnumerable<string> parts, bool ignoreCase = true)
+        {
+            var comparer = ignoreCase ? StringComparer.CurrentCultureIgnoreCase : StringComparer.CurrentCulture;
+            return field.Parts.SequenceEqual(parts, comparer);
+        }
+
+        public static bool Is(this LuFieldDbo field, string parts, bool ignoreCase = true)
+        {
+            return field.Is(LuFieldDbo.Make(parts), ignoreCase);
+        }
+
+        public static bool Is(this LuFieldDbo field, LuFieldDbo path, bool ignoreCase = true)
+        {
+            return field.Is(path.Parts, ignoreCase);
+        }
+
+        public static bool Is<TDbo>(this LuFieldDbo field, Expression<Func<TDbo, object>> property, bool ignoreCase = true)
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression(property);
+            var memberInfoString = memberInfo.Select(x => x.Name).ToList();
+            return field.Is(memberInfoString, ignoreCase);
+        }
+
+
+        public static bool IsRoot(this LuFieldDbo field)
+        {
+            return !field.Parts.Any();
+        }
+
+        public static LuFieldDbo Pop(this LuFieldDbo field)
+        {
+            field.Parts = field.Parts.Where((s, i) => i != 0).ToList();
+            return field;
+        }
+
+        public static LuFieldDbo Popped(this LuFieldDbo field)
+        {
+            var newField = LuFieldDbo.Make(field).Pop();
+            return newField;
+        }
+
+
+        public static LuFieldDbo Add(this LuFieldDbo field, IEnumerable<string> parts)
+        {
+            foreach (var property in parts)
+            {
+                if (!string.IsNullOrEmpty(property))
+                {
+                    field.Parts.Add(property);
+                }
+            }
+
+            return field;
+        }
+
+        public static LuFieldDbo Add(this LuFieldDbo field, LuFieldDbo path)
+        {
+            return field.Add(path.Parts);
+        }
+
+        public static LuFieldDbo Add(this LuFieldDbo field, string path)
+        {
+            return field.Add(Regex.Split(path, "[\\./]"));
+        }
+
+        public static LuFieldDbo Add<TTypeTo>(this LuFieldDbo field, Expression<Func<TTypeTo, object>> property)
+        {
+            var memberInfo = LuExpressionUtils.GetMembersFromExpression(property);
+
+            if (memberInfo == null)
+            {
+                throw new ArgumentException("Invalid property", nameof(property));
+            }
+            
+            return field.Add(memberInfo.Select(x => x.Name));
+        }
+    }
+}

Luticate2.Auth/Business/Fields/LuPartialFieldsParser.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Fields
+{
+    public class LuPartialFieldsParser
+    {
+        public static LuResult<LuPartialFieldsDbo> Parse(string fields)
+        {
+            if (PartialResponse.Core.Fields.TryParse(fields, out var tempFields))
+            {
+                var partialFieldsDbo = new LuPartialFieldsDbo
+                {
+                    Fields = tempFields.Values.Select(x => new LuFieldDbo {Parts = x.Parts.ToList()}).ToList()
+                };
+                return LuResult<LuPartialFieldsDbo>.Ok(partialFieldsDbo);
+            }
+            return LuResult<LuPartialFieldsDbo>.Error(LuStatus.InputError.ToInt(), "Failed to parse partial fields", "");
+        }
+    }
+}

Luticate2.Auth/Business/FieldsExpressions/Basic/LuFieldsExpressionsString.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.FieldsExpressions.Basic
+{
+    public class LuFieldsExpressionsString : LuFieldsExpressions<string, string>
+    {
+        public LuFieldsExpressionsString(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, string>> modelProperty, LuFieldDbo field)
+        {
+            if (field.StartsWith<string>(x => x.Length))
+            {
+                return GetSubField<TType1, int, int>(modelProperty, field, x => x.Length);
+            }
+            return base.GetExpressionInternal(modelProperty, field);
+        }
+    }
+}

Luticate2.Auth/Business/FieldsExpressions/LuFieldsExpressions.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Luticate2.Auth.Business.FieldsExpressions
+{
+    public class LuFieldsExpressions<TDbo, TModel> : ILuFieldsExpressions<TDbo, TModel>
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        public LuFieldsExpressions(IServiceProvider serviceProvider)
+        {
+            ServiceProvider = serviceProvider;
+        }
+        
+        public ILuFieldsExpressions<TDbo2, TModel2> GetService<TDbo2, TModel2>()
+        {
+            var service = ServiceProvider.GetService<ILuFieldsExpressions<TDbo2, TModel2>>();
+            return service;
+        }
+
+        protected LuResult<Expression<Func<TType1, object>>> GetSubField<TType1, TType2, TType3>(
+            Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field, Expression<Func<TModel, TType3>> modelSubProperty)
+        {
+            var subPropExprResult = LuExpressionUtils.GetSingleMemberFromExpression(modelSubProperty);
+            if (subPropExprResult == null)
+            {
+                return LuResult<Expression<Func<TType1, object>>>.Error(LuStatus.InternalError.ToInt(), "Bad field expression");
+            }
+
+            var prop = Expression.Property(modelProperty.Body, subPropExprResult.Name);
+            var exp = Expression.Lambda<Func<TType1, TType3>>(prop, modelProperty.Parameters[0]);
+            var service = GetService<TType2, TType3>();
+            var finalExpResult = service.GetExpression(exp, field.Popped());
+            return finalExpResult;
+        }
+
+        protected virtual LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(
+            Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field)
+        {
+            return LuResult<Expression<Func<TType1, object>>>.Error(LuStatus.InputError.ToInt(), $"Unknown field: {field}", "");
+        }
+
+        public virtual LuResult<Expression<Func<TType1, object>>> GetExpression<TType1>(Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field)
+        {
+            if (field.IsRoot())
+            {
+                var converted = Expression.Convert(modelProperty.Body, typeof(object));
+                var exp = Expression.Lambda<Func<TType1, object>>(converted, modelProperty.Parameters[0]);
+                return LuResult<Expression<Func<TType1, object>>>.Ok(exp);
+            }
+            return GetExpressionInternal(modelProperty, field);
+        }
+    }
+}

Luticate2.Auth/Business/LuExpressionUtils.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business
+{
+    public static class LuExpressionUtils
+    {
+        public static Expression GetFromConvert<TType1, TType2>(Expression<Func<TType1, TType2>> exp)
+        {
+            Expression operand;
+            if ((exp.Body.NodeType == ExpressionType.Convert ||
+                 exp.Body.NodeType == ExpressionType.ConvertChecked)
+                && exp.Body is UnaryExpression)
+            {
+                operand = ((UnaryExpression) exp.Body).Operand;
+            }
+            else
+            {
+                operand = exp.Body;
+            }
+
+            return operand;
+        }
+
+        public static Expression<Func<TType1, TType3>> AddConvert<TType1, TType2, TType3>(Expression<Func<TType1, TType2>> exp)
+        {
+            var converted = Expression.Convert(exp, typeof(object));
+            var expLambda = Expression.Lambda<Func<TType1, TType3>>(converted, exp.Parameters);
+            return expLambda;
+        }
+
+        public static LuResult<TProperty> SetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
+            TDbo dboTo, TProperty value)
+        {
+            var memberInfo = GetSingleMemberFromExpression(property);
+            if (memberInfo != null)
+            {
+                switch (memberInfo.MemberType)
+                {
+                    case MemberTypes.Field:
+                        ((FieldInfo) memberInfo).SetValue(dboTo, value);
+                        return LuResult<TProperty>.Ok(value);
+                    case MemberTypes.Property:
+                        ((PropertyInfo) memberInfo).SetValue(dboTo, value);
+                        return LuResult<TProperty>.Ok(value);
+                    default:
+                        return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
+                            $"Bad MemberType: {memberInfo.MemberType}");
+                }
+            }
+
+            return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
+        }
+
+        public static LuResult<TProperty> GetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
+            TDbo dboTo)
+        {
+            var memberInfo = GetSingleMemberFromExpression(property);
+            if (memberInfo != null)
+            {
+                TProperty value;
+                switch (memberInfo.MemberType)
+                {
+                    case MemberTypes.Field:
+                        value = (TProperty) ((FieldInfo) memberInfo).GetValue(dboTo);
+                        return LuResult<TProperty>.Ok(value);
+                    case MemberTypes.Property:
+                        value = (TProperty) ((PropertyInfo) memberInfo).GetValue(dboTo);
+                        return LuResult<TProperty>.Ok(value);
+                    default:
+                        return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
+                            $"Bad MemberType: {memberInfo.MemberType}");
+                }
+            }
+
+            return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
+        }
+
+        public static MemberInfo GetSingleMemberFromExpression<TTypeTo, TProperty>(Expression<Func<TTypeTo, TProperty>> property)
+        {
+            var memberExpression = GetFromConvert(property) as MemberExpression;
+
+            if (memberExpression != null && memberExpression.Expression == property.Parameters.First())
+            {
+                return memberExpression.Member;
+            }
+            return null;
+        }
+
+        private static bool GetMembersFromExpression<TTypeTo, TProperty>(
+            Expression<Func<TTypeTo, TProperty>> property, IList<MemberInfo> memberInfos)
+        {
+            MemberExpression memberExpression;
+            if ((property.Body.NodeType == ExpressionType.Convert ||
+                 property.Body.NodeType == ExpressionType.ConvertChecked)
+                && property.Body is UnaryExpression)
+            {
+                memberExpression = ((UnaryExpression) property.Body).Operand as MemberExpression;
+            }
+            else
+            {
+                memberExpression = property.Body as MemberExpression;
+            }
+
+            if (memberExpression != null)
+            {
+                if (memberExpression.Expression == property.Parameters.First())
+                {
+                    memberInfos.Add(memberExpression.Member);
+                    return true;
+                }
+                else if (memberExpression.Expression is MemberExpression)
+                {
+                    var exp = Expression.Lambda<Func<TTypeTo, object>>(memberExpression.Expression, property.Parameters);
+                    var res = GetMembersFromExpression(exp, memberInfos);
+                    if (res)
+                    {
+                        memberInfos.Add(memberExpression.Member);
+                    }
+
+                    return res;
+                }
+            }
+            return false;
+        }
+
+        public static IList<MemberInfo> GetMembersFromExpression<TTypeTo, TProperty>(Expression<Func<TTypeTo, TProperty>> property)
+        {
+            var list = new List<MemberInfo>();
+            if (GetMembersFromExpression(property, list))
+            {
+                return list;
+            }
+
+            return null;
+        }
+    }
+}

Luticate2.Auth/Business/Pagination/LuFilterParser.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.Result;
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
+
+namespace Luticate2.Auth.Business.Pagination
+{
+    public class LuFilterParser
+    {
+        public static LuResult<LuFilterDbo> Parse<T>(string data)
+        {
+            var completeData = $"(x) => ({data})";
+            try
+            {
+                var options = ScriptOptions.Default.AddReferences(typeof(LuFilterParser).Assembly);
+                var expr = CSharpScript.EvaluateAsync<Expression<Func<T, bool>>>(completeData, options).Result;
+                return LuResult<LuFilterDbo>.Ok(new LuFilterDbo
+                {
+                    Expression = expr
+                });
+            }
+            catch (Exception e)
+            {
+                return LuResult<LuFilterDbo>.Error(LuStatus.InputError.ToInt(), e);
+            }
+        }
+    }
+}

Luticate2.Auth/Business/Pagination/LuOrderByParser.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Business.Pagination
+{
+    public class LuOrderByParser
+    {
+        public static LuResult<LuOrderByDbo> Parse(string data)
+        {
+            if (data == null)
+            {
+                data = "";
+            }
+            data = data.Trim();
+            if (data != "")
+            {
+                var dbo = new LuOrderByDbo {OrderByFields = new List<LuOrderByFieldDbo>()};
+                var fields = data.Split(',');
+                foreach (var field in fields)
+                {
+                    if (field == "")
+                    {
+                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
+                            $"LuOrderByParser: {data}", "Empty order by field");
+                    }
+                    var orderByField = new LuOrderByFieldDbo();
+                    var split = field.Split(':');
+                    if (split.Length > 2 || split.Length == 0)
+                    {
+                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
+                            $"LuOrderByParser: {data}", "Invalid order by field syntax");
+                    }
+                    orderByField.Field = LuFieldDbo.Make(split[0]);
+                    var order = split.Length == 2 ? split[1].ToLower() : "asc";
+                    if (order == "asc")
+                    {
+                        orderByField.Asc = true;
+                    }
+                    else if (order == "desc")
+                    {
+                        orderByField.Asc = false;
+                    }
+                    else
+                    {
+                        return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(),
+                            $"LuOrderByParser: {data}", "Empty order by field order");
+                    }
+                    dbo.OrderByFields.Add(orderByField);
+                }
+                return LuResult<LuOrderByDbo>.Ok(dbo);
+            }
+            return LuResult<LuOrderByDbo>.Error(LuStatus.InputError.ToInt(), "Order by is empty or missing", "");
+        }
+    }
+}

Luticate2.Auth/Business/PartialObjectCopier/LuPartialObjectCopier.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Dbo;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Luticate2.Auth.Business.PartialObjectCopier
+{
+    public abstract class LuPartialObjectCopier<TTypeFrom, TTypeTo> : ILuPartialObjectCopier<TTypeFrom, TTypeTo>
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        protected LuPartialObjectCopier(IServiceProvider serviceProvider)
+        {
+            ServiceProvider = serviceProvider;
+        }
+
+        protected LuResult<TPropertyTo> MayCopySubProperty<TPropertyFrom, TPropertyTo>(LuFieldDbo path,
+            LuPartialFieldsDbo fields, TTypeFrom modelFrom, TTypeTo dboTo,
+            Expression<Func<TTypeFrom, TPropertyFrom>> propFrom, Expression<Func<TTypeTo, TPropertyTo>> propTo,
+            LuPartialObjectCopierOptions options) where TPropertyTo : new()
+        {
+            var member = LuExpressionUtils.GetSingleMemberFromExpression(propTo);
+            var subpath = LuFieldDbo.Make(path).Add(member.Name);
+            if (fields.Fields.IsIncluded(subpath))
+            {
+                var propToValue = LuExpressionUtils.GetValueFromExpression(propTo, dboTo);
+                if (!propToValue)
+                {
+                    return propToValue.To<TPropertyTo>();
+                }
+                if (propToValue.Data == null)
+                {
+                    propToValue.Data = new TPropertyTo();
+                    var res = LuExpressionUtils.SetValueFromExpression(propTo, dboTo, propToValue.Data);
+                    if (!res)
+                    {
+                        return res.To<TPropertyTo>();
+                    }
+                }
+                var propFromValue = LuExpressionUtils.GetValueFromExpression(propFrom, modelFrom);
+                if (!propFromValue)
+                {
+                    return propFromValue.To<TPropertyTo>();
+                }
+
+                var service = ServiceProvider.GetService<ILuPartialObjectCopier<TPropertyFrom, TPropertyTo>>();
+                var result = service.Copy(subpath, fields, propFromValue.Data, propToValue.Data, options);
+                return result;
+            }
+            return LuResult<TPropertyTo>.Ok(default(TPropertyTo));
+        }
+
+        protected LuResult<IList<TPropertyTo>> MayCopySubPropertyList<TPropertyFrom, TPropertyTo>(
+            LuFieldDbo path, LuPartialFieldsDbo fields, IEnumerable<TPropertyFrom> modelFrom,
+            TTypeTo dboTo, Expression<Func<TTypeTo, IEnumerable<TPropertyTo>>> propTo,
+            LuPartialObjectCopierOptions options) where TPropertyTo : new()
+        {
+            var member = LuExpressionUtils.GetSingleMemberFromExpression(propTo);
+            var subpath = LuFieldDbo.Make(path).Add(member.Name);
+            if (fields.Fields.IsIncluded(subpath))
+            {
+                var list = new List<TPropertyTo>();
+                var res = LuExpressionUtils.SetValueFromExpression(propTo, dboTo, list);
+                if (!res)
+                {
+                    return res.To<IList<TPropertyTo>>();
+                }
+
+                foreach (var subDboFrom in modelFrom)
+                {
+                    var subDboTo = new TPropertyTo();
+
+                    var service = ServiceProvider.GetService<ILuPartialObjectCopier<TPropertyFrom, TPropertyTo>>();
+                    var result = service.Copy(subpath, fields, subDboFrom, subDboTo, options);
+
+                    list.Add(subDboTo);
+                }
+            }
+            return LuResult<IList<TPropertyTo>>.Ok(null);
+        }
+
+        protected LuResult<TProperty> MayCopy<TProperty, TTypeTo2>(LuFieldDbo path, LuPartialFieldsDbo fields,
+            TTypeTo2 dboTo, Expression<Func<TTypeTo2, TProperty>> property, Func<TProperty> getValue)
+        {
+            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(property);
+            if (memberInfo != null)
+            {
+                if (fields.Fields.IsIncluded(LuFieldDbo.Make(path).Add(memberInfo.Name)))
+                {
+                    var value = getValue();
+                    var result = LuExpressionUtils.SetValueFromExpression(property, dboTo, value);
+                    return result;
+                }
+
+                return LuResult<TProperty>.Ok(default(TProperty));
+            }
+
+            return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
+        }
+
+        public abstract LuResult<TTypeTo> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options);
+
+        public LuResult<TTypeTo> Copy(LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options)
+        {
+            return Copy(new LuFieldDbo(), fields, dboFrom, dboTo, options);
+        }
+    }
+}

Luticate2.Auth/Business/PartialObjectCopier/LuPartialObjectCopierExtensions.cs

@@ -0,0 +1,11 @@
+namespace Luticate2.Auth.Business.PartialObjectCopier
+{
+    public static class LuPartialObjectCopierExtensions
+    {
+//        public static LuResult<TTypeTo> CopyList<TTypeFrom, TTypeTo>(this ILuPartialObjectCopier<TTypeFrom, TTypeTo> copier,
+//            ILuPartialFields fields, TTypeFrom dboFrom, TTypeTo dboTo)
+//        {
+//
+//        }
+    }
+}

Luticate2.Auth/Business/Serializers/PartialJson/LuJsonSerializerExtensions.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Luticate2.Auth.Business.Serializers.PartialJson
+{
+    /// <summary>
+    /// Provides a method for serializing objects to JSON.
+    /// </summary>
+    /// <remarks>This type supports the <see cref="PartialResponse.Core.Fields"/> infrastructure and is not intended to be used directly
+    /// from your code.</remarks>
+    public static class LuJsonSerializerExtensions
+    {
+        /// <summary>
+        /// Serializes the specified <see cref="object"/> and writes the JSON structure
+        /// using the specified <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> used to serialize the specified <see cref="object"/>.</param>
+        /// <param name="jsonWriter">The <see cref="JsonWriter"/> used to write the JSON structure.</param>
+        /// <param name="value">The <see cref="object"/> to serialize.</param>
+        /// <param name="shouldSerialize">A <see cref="Func{T, TResult}"/> that is called for every field in the
+        /// <see cref="object"/> to serialize, indicating whether the field should be serialized.</param>
+        public static void Serialize(this JsonSerializer jsonSerializer, JsonWriter jsonWriter, object value, Func<string, bool> shouldSerialize)
+        {
+            if (value == null)
+            {
+                jsonSerializer.Serialize(jsonWriter, value);
+            }
+            else
+            {
+                var context = new LuSerializerContext(shouldSerialize);
+                var token = JToken.FromObject(value, jsonSerializer);
+
+                if (token is JArray array)
+                {
+                    RemoveArrayElements(array, null, context);
+
+                    array.WriteTo(jsonWriter);
+                }
+                else
+                {
+                    if (token is JObject @object)
+                    {
+                        RemoveObjectProperties(@object, null, context);
+
+                        @object.WriteTo(jsonWriter);
+                    }
+                    else
+                    {
+                        token.WriteTo(jsonWriter);
+                    }
+                }
+            }
+        }
+
+        private static void RemoveArrayElements(JArray array, string currentPath, LuSerializerContext context)
+        {
+            var containsChildItems = array.Count > 0;
+
+            array.OfType<JObject>()
+                .ToList()
+                .ForEach(childObject => RemoveObjectProperties(childObject, currentPath, context));
+
+            // PartialResponse should only remove an array when it initially contained items, but was empty after filtering.
+            if (containsChildItems)
+            {
+                RemoveArrayIfEmpty(array);
+            }
+        }
+
+        private static void RemoveArrayIfEmpty(JArray array)
+        {
+            if (array.Count == 0)
+            {
+                if (array.Parent is JProperty && array.Parent.Parent != null)
+                {
+                    array.Parent.Remove();
+                }
+                else if (array.Parent is JArray)
+                {
+                    array.Remove();
+                }
+            }
+        }
+
+        private static void RemoveObjectProperties(JObject @object, string currentPath, LuSerializerContext context)
+        {
+            @object.Properties()
+                .Where(property =>
+                {
+                    var path = CombinePath(currentPath, property.Name);
+
+                    return !context.ShouldSerialize(path);
+                })
+                .ToList()
+                .ForEach(property => property.Remove());
+
+            @object.Properties()
+                .Where(property => property.Value is JObject)
+                .ToList()
+                .ForEach(property =>
+                {
+                    var path = CombinePath(currentPath, property.Name);
+
+                    RemoveObjectProperties((JObject)property.Value, path, context);
+                });
+
+            @object.Properties()
+                .Where(property => property.Value is JArray)
+                .ToList()
+                .ForEach(property =>
+                {
+                    var path = CombinePath(currentPath, property.Name);
+
+                    RemoveArrayElements((JArray)property.Value, path, context);
+                });
+
+            RemoveObjectIfEmpty(@object);
+        }
+
+        private static void RemoveObjectIfEmpty(JObject @object)
+        {
+            if (!@object.Properties().Any())
+            {
+                if (@object.Parent is JProperty && @object.Parent.Parent != null)
+                {
+                    @object.Parent.Remove();
+                }
+                else if (@object.Parent is JArray)
+                {
+                    @object.Remove();
+                }
+            }
+        }
+
+        private static string CombinePath(string path, string name)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return name;
+            }
+
+            return $"{path}/{name}";
+        }
+    }
+}

Luticate2.Auth/Business/Serializers/PartialJson/LuPartialJsonWriter.cs

@@ -0,0 +1,30 @@
+using System.IO;
+using Luticate2.Auth.Business.Fields;
+using Luticate2.Auth.Dbo.Fields;
+using Newtonsoft.Json;
+
+namespace Luticate2.Auth.Business.Serializers.PartialJson
+{
+    public class LuPartialJsonWriter
+    {
+        public static string SerializeObject(object data, LuPartialFieldsDbo partialResponseDbo, JsonSerializerSettings settings)
+        {
+            var stringWriter = new StringWriter();
+            SerializeObject(data, partialResponseDbo, settings, stringWriter);
+            var result = stringWriter.ToString();
+            return result;
+        }
+
+        public static void SerializeObject(object data, LuPartialFieldsDbo partialResponseDbo, JsonSerializerSettings settings, TextWriter writer)
+        {
+            using (var jsonWriter = new JsonTextWriter(writer))
+            {
+                jsonWriter.CloseOutput = false;
+
+                var jsonSerializer = JsonSerializer.Create(settings);
+
+                jsonSerializer.Serialize(jsonWriter, data, path => partialResponseDbo.Fields.IsIncluded(path));
+            }
+        }
+    }
+}

Luticate2.Auth/Business/Serializers/PartialJson/LuSerializerContext.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.Business.Serializers.PartialJson
+{
+    internal class LuSerializerContext
+    {
+        private readonly Func<string, bool> shouldSerialize;
+        private readonly Dictionary<string, bool> cache = new Dictionary<string, bool>();
+
+        public LuSerializerContext(Func<string, bool> shouldSerialize)
+        {
+            this.shouldSerialize = shouldSerialize;
+        }
+
+        public bool ShouldSerialize(string path)
+        {
+            if (this.cache.ContainsKey(path))
+            {
+                return this.cache[path];
+            }
+
+            var result = this.shouldSerialize(path);
+
+            this.cache.Add(path, result);
+
+            return result;
+        }
+    }
+}

Luticate2.Auth/Class1.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace Luticate2.Auth
-{
-    public class Class1
-    {
-        public static string Method1(string arg1)
-        {
-            return $"testValue {arg1}";
-        }
-    }
-}

Luticate2.Auth/DataAccess/Luticate2DbContext.cs

@@ -0,0 +1,122 @@
+using Luticate2.Auth.DataAccess.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Luticate2.Auth.DataAccess
+{
+    public class Luticate2DbContext : DbContext
+    {
+        public virtual DbSet<LuGroups> LuGroups { get; set; }
+        public virtual DbSet<LuGroupsObjects> LuGroupsObjects { get; set; }
+        public virtual DbSet<LuObjectsMetadata> LuObjectsMetadata { get; set; }
+        public virtual DbSet<LuUsers> LuUsers { get; set; }
+
+        public Luticate2DbContext()
+        {
+        }
+
+        public Luticate2DbContext(DbContextOptions options) : base(options)
+        {
+        }
+        
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.HasPostgresExtension("citext")
+                .HasPostgresExtension("unaccent")
+                .HasPostgresExtension("uuid-ossp");
+
+            modelBuilder.Entity<LuGroups>(entity =>
+            {
+                entity.ToTable("lu_groups", "luticate2");
+
+                entity.HasIndex(e => e.Name)
+                    .HasName("lu_groups_name_key")
+                    .IsUnique();
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_groups'::text)");
+
+                entity.Property(e => e.Name)
+                    .IsRequired()
+                    .HasColumnName("name")
+                    .HasColumnType("citext");
+
+                entity.HasOne(d => d.IdNavigation)
+                    .WithOne(p => p.LuGroups)
+                    .HasForeignKey<LuGroups>(d => d.Id)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_groups_id_fkey");
+            });
+
+            modelBuilder.Entity<LuGroupsObjects>(entity =>
+            {
+                entity.HasKey(e => new { e.GroupId, e.ObjectId });
+
+                entity.ToTable("lu_groups_objects", "luticate2");
+
+                entity.HasIndex(e => new { e.ObjectId, e.Priority })
+                    .HasName("lu_groups_objects_object_id_priority_key")
+                    .IsUnique();
+
+                entity.Property(e => e.GroupId).HasColumnName("group_id");
+
+                entity.Property(e => e.ObjectId).HasColumnName("object_id");
+
+                entity.Property(e => e.Priority).HasColumnName("priority");
+
+                entity.HasOne(d => d.Group)
+                    .WithMany(p => p.LuGroupsObjects)
+                    .HasForeignKey(d => d.GroupId)
+                    .HasConstraintName("lu_groups_objects_group_id_fkey");
+
+                entity.HasOne(d => d.Object)
+                    .WithMany(p => p.LuGroupsObjects)
+                    .HasForeignKey(d => d.ObjectId)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_groups_objects_object_id_fkey");
+            });
+
+            modelBuilder.Entity<LuObjectsMetadata>(entity =>
+            {
+                entity.ToTable("lu_objects_metadata", "luticate2");
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_objects_metadata'::text)");
+
+                entity.Property(e => e.CreatedAt)
+                    .HasColumnName("created_at")
+                    .HasColumnType("timestamp with time zone")
+                    .HasDefaultValueSql("now()");
+
+                entity.Property(e => e.UpdatedAt)
+                    .HasColumnName("updated_at")
+                    .HasColumnType("timestamp with time zone");
+            });
+
+            modelBuilder.Entity<LuUsers>(entity =>
+            {
+                entity.ToTable("lu_users", "luticate2");
+
+                entity.HasIndex(e => e.Username)
+                    .HasName("lu_users_username_key")
+                    .IsUnique();
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_users'::text)");
+
+                entity.Property(e => e.Username)
+                    .IsRequired()
+                    .HasColumnName("username")
+                    .HasColumnType("citext");
+
+                entity.HasOne(d => d.IdNavigation)
+                    .WithOne(p => p.LuUsers)
+                    .HasForeignKey<LuUsers>(d => d.Id)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_users_id_fkey");
+            });
+        }
+    }
+}

Luticate2.Auth/DataAccess/Models/LuGroups.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class LuGroups
+    {
+        public LuGroups()
+        {
+            LuGroupsObjects = new HashSet<LuGroupsObjects>();
+        }
+
+        public Guid Id { get; set; }
+        public string Name { get; set; }
+
+        public LuObjectsMetadata IdNavigation { get; set; }
+        public ICollection<LuGroupsObjects> LuGroupsObjects { get; set; }
+    }
+}

Luticate2.Auth/DataAccess/Models/LuGroupsObjects.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class LuGroupsObjects
+    {
+        public Guid GroupId { get; set; }
+        public Guid ObjectId { get; set; }
+        public int? Priority { get; set; }
+
+        public LuGroups Group { get; set; }
+        public LuObjectsMetadata Object { get; set; }
+    }
+}

Luticate2.Auth/DataAccess/Models/LuObjectsMetadata.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class LuObjectsMetadata
+    {
+        public LuObjectsMetadata()
+        {
+            LuGroupsObjects = new HashSet<LuGroupsObjects>();
+        }
+
+        public Guid Id { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+
+        public LuGroups LuGroups { get; set; }
+        public LuUsers LuUsers { get; set; }
+        public ICollection<LuGroupsObjects> LuGroupsObjects { get; set; }
+    }
+}

Luticate2.Auth/DataAccess/Models/LuUsers.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class LuUsers
+    {
+        public Guid Id { get; set; }
+        public string Username { get; set; }
+
+        public LuObjectsMetadata IdNavigation { get; set; }
+    }
+}

Luticate2.Auth/DataAccess/Models/TestTable.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class TestTable
+    {
+        public Guid Id { get; set; }
+    }
+}

Luticate2.Auth/DataAccess/Models/luticate2Context.cs

@@ -0,0 +1,133 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public partial class luticate2Context : DbContext
+    {
+        public luticate2Context()
+        {
+        }
+
+        public luticate2Context(DbContextOptions<luticate2Context> options)
+            : base(options)
+        {
+        }
+
+        public virtual DbSet<LuGroups> LuGroups { get; set; }
+        public virtual DbSet<LuGroupsObjects> LuGroupsObjects { get; set; }
+        public virtual DbSet<LuObjectsMetadata> LuObjectsMetadata { get; set; }
+        public virtual DbSet<LuUsers> LuUsers { get; set; }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            if (!optionsBuilder.IsConfigured)
+            {
+#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
+                optionsBuilder.UseNpgsql("Host=localhost;Database=luticate2;Username=dev;Password=dev");
+            }
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.HasPostgresExtension("citext")
+                .HasPostgresExtension("unaccent")
+                .HasPostgresExtension("uuid-ossp");
+
+            modelBuilder.Entity<LuGroups>(entity =>
+            {
+                entity.ToTable("lu_groups", "luticate2");
+
+                entity.HasIndex(e => e.Name)
+                    .HasName("lu_groups_name_key")
+                    .IsUnique();
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_groups'::text)");
+
+                entity.Property(e => e.Name)
+                    .IsRequired()
+                    .HasColumnName("name")
+                    .HasColumnType("citext");
+
+                entity.HasOne(d => d.IdNavigation)
+                    .WithOne(p => p.LuGroups)
+                    .HasForeignKey<LuGroups>(d => d.Id)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_groups_id_fkey");
+            });
+
+            modelBuilder.Entity<LuGroupsObjects>(entity =>
+            {
+                entity.HasKey(e => new { e.GroupId, e.ObjectId });
+
+                entity.ToTable("lu_groups_objects", "luticate2");
+
+                entity.HasIndex(e => new { e.ObjectId, e.Priority })
+                    .HasName("lu_groups_objects_object_id_priority_key")
+                    .IsUnique();
+
+                entity.Property(e => e.GroupId).HasColumnName("group_id");
+
+                entity.Property(e => e.ObjectId).HasColumnName("object_id");
+
+                entity.Property(e => e.Priority).HasColumnName("priority");
+
+                entity.HasOne(d => d.Group)
+                    .WithMany(p => p.LuGroupsObjects)
+                    .HasForeignKey(d => d.GroupId)
+                    .HasConstraintName("lu_groups_objects_group_id_fkey");
+
+                entity.HasOne(d => d.Object)
+                    .WithMany(p => p.LuGroupsObjects)
+                    .HasForeignKey(d => d.ObjectId)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_groups_objects_object_id_fkey");
+            });
+
+            modelBuilder.Entity<LuObjectsMetadata>(entity =>
+            {
+                entity.ToTable("lu_objects_metadata", "luticate2");
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_objects_metadata'::text)");
+
+                entity.Property(e => e.CreatedAt)
+                    .HasColumnName("created_at")
+                    .HasColumnType("timestamp with time zone")
+                    .HasDefaultValueSql("now()");
+
+                entity.Property(e => e.UpdatedAt)
+                    .HasColumnName("updated_at")
+                    .HasColumnType("timestamp with time zone");
+            });
+
+            modelBuilder.Entity<LuUsers>(entity =>
+            {
+                entity.ToTable("lu_users", "luticate2");
+
+                entity.HasIndex(e => e.Username)
+                    .HasName("lu_users_username_key")
+                    .IsUnique();
+
+                entity.Property(e => e.Id)
+                    .HasColumnName("id")
+                    .HasDefaultValueSql("luticate2.lu_sp_generate_uuid('lu_users'::text)");
+
+                entity.Property(e => e.Username)
+                    .IsRequired()
+                    .HasColumnName("username")
+                    .HasColumnType("citext");
+
+                entity.HasOne(d => d.IdNavigation)
+                    .WithOne(p => p.LuUsers)
+                    .HasForeignKey<LuUsers>(d => d.Id)
+                    .OnDelete(DeleteBehavior.ClientSetNull)
+                    .HasConstraintName("lu_users_id_fkey");
+            });
+        }
+    }
+}

Luticate2.Auth/Dbo/Auth/LuGroupDbo.cs

@@ -0,0 +1,7 @@
+namespace Luticate2.Auth.Dbo.Auth
+{
+    public class LuGroupDbo : LuObjectDbo
+    {
+        public string Name { get; set; }
+    }
+}

Luticate2.Auth/Dbo/Auth/LuObjectDbo.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Luticate2.Auth.Dbo.Auth
+{
+    public class LuObjectDbo
+    {
+        public Guid Id { get; set; }
+        
+        public LuObjectsMetadataDbo Metadata { get; set; }
+    }
+}

Luticate2.Auth/Dbo/Auth/LuObjectsMetadataDbo.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Luticate2.Auth.Dbo.Auth
+{
+    public class LuObjectsMetadataDbo
+    {
+        public Guid Id { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public DateTime? UpdatedAt { get; set; }
+    }
+}

Luticate2.Auth/Dbo/Basic/LuAuthOptions.cs

@@ -1,7 +0,0 @@
-namespace Luticate2.Auth.Dbo.Basic
-{
-    public class LuAuthOptions
-    {
-        public string Version { get; set; }
-    }
-}

Luticate2.Auth/Dbo/Fields/LuFieldDbo.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Business.Fields;
+
+namespace Luticate2.Auth.Dbo.Fields
+{
+    public class LuFieldDbo
+    {
+        public IList<string> Parts { get; set; } = new List<string>();
+
+        public static LuFieldDbo Make(IEnumerable<string> parts)
+        {
+            var partialFieldpath = new LuFieldDbo();
+            return partialFieldpath.Add(parts);
+        }
+
+        public static LuFieldDbo Make(string path)
+        {
+            var partialFieldpath = new LuFieldDbo();
+            return partialFieldpath.Add(path);
+        }
+
+        public static LuFieldDbo Make(LuFieldDbo path)
+        {
+            var partialFieldpath = new LuFieldDbo();
+            return partialFieldpath.Add(path);
+        }
+
+        public static LuFieldDbo Make<TTypeTo>(Expression<Func<TTypeTo, object>> property)
+        {
+            var partialFieldpath = new LuFieldDbo();
+            return partialFieldpath.Add(property);
+        }
+
+        public LuFieldDbo Copy()
+        {
+            return new LuFieldDbo
+            {
+                Parts = Parts.ToList()
+            };
+        }
+        
+        public override string ToString()
+        {
+            return string.Join("/", Parts);
+        }
+    }
+}

Luticate2.Auth/Dbo/Fields/LuPartialFieldsDbo.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Luticate2.Auth.Dbo.Fields
+{
+    public class LuPartialFieldsDbo
+    {
+        public IList<LuFieldDbo> Fields { get; set; }
+    }
+}

Luticate2.Auth/Dbo/LuDboExtensions.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Luticate2.Auth.Dbo.Pagination;
-using Luticate2.Auth.Dbo.Result;
+using Luticate2.Auth.Dbo.Result;
 
 namespace Luticate2.Auth.Dbo
 {
@@ -12,24 +8,5 @@ namespace Luticate2.Auth.Dbo
         {
             return (int) status;
         }
-
-        // TODO?
-//        public static LuPaginatedDbo<TDbo> To<TDbo>(this LuPaginatedDbo<TDbo> data, Func<List<TDbo>, List<TDbo>> convert)
-//        {
-//            return new LuPaginatedDbo<TDbo>
-//            {
-//                Count = data.Count,
-//                Data = convert(data.Data)
-//            };
-//        }
-//
-//        public static LuPaginatedDbo<TDbo> Select<TDbo>(this LuPaginatedDbo<TDbo> data, Func<TDbo, TDbo> convert)
-//        {
-//            return new LuPaginatedDbo<TDbo>
-//            {
-//                Count = data.Count,
-//                Data = data.Data.Select(convert).ToList()
-//            };
-//        }
     }
 }

Luticate2.Auth/Dbo/Pagination/LuFilterDbo.cs

@@ -1,54 +1,9 @@
-using System.Collections.Generic;
+using System.Linq.Expressions;
 
 namespace Luticate2.Auth.Dbo.Pagination
 {
     public class LuFilterDbo
     {
-        public string Query { get; set; }
-
-        public IDictionary<string, string> Filters { get; set; }
-
-        public string GetFilterString(string key, string defaultValue)
-        {
-            if (!Filters.ContainsKey(key))
-            {
-                return defaultValue;
-            }
-            return Filters[key];
-        }
-
-        public bool? GetFilterBool(string key, bool? defaultValue)
-        {
-            var value = GetFilterString(key, "").ToLower();
-            if (value == "true")
-            {
-                return true;
-            }
-            if (value == "false")
-            {
-                return false;
-            }
-            return defaultValue;
-        }
-
-        public int? GetFilterInt(string key, int? defaultValue)
-        {
-            int v;
-            if (int.TryParse(GetFilterString(key, ""), out v))
-            {
-                return v;
-            }
-            return defaultValue;
-        }
-
-        public double? GetFilterFloat(string key, double? defaultValue)
-        {
-            double v;
-            if (double.TryParse(GetFilterString(key, ""), out v))
-            {
-                return v;
-            }
-            return defaultValue;
-        }
+        public Expression Expression { get; set; }
     }
 }

Luticate2.Auth/Dbo/Pagination/LuOrderByDbo.cs

@@ -4,6 +4,6 @@ namespace Luticate2.Auth.Dbo.Pagination
 {
     public class LuOrderByDbo
     {
-        public IList<LuOrderByFieldDbo> Fields { get; set; }
+        public IList<LuOrderByFieldDbo> OrderByFields { get; set; }
     }
 }

Luticate2.Auth/Dbo/Pagination/LuOrderByFieldDbo.cs

@@ -1,9 +1,17 @@
-namespace Luticate2.Auth.Dbo.Pagination
+using Luticate2.Auth.Dbo.Fields;
+
+namespace Luticate2.Auth.Dbo.Pagination
 {
     public class LuOrderByFieldDbo
     {
-        public string Name { get; set; }
+        public LuFieldDbo Field { get; set; }
+
+        public bool Asc { get; set; } = true;
 
-        public bool Asc { get; set; }
+        public override string ToString()
+        {
+            var asc = Asc ? "ASC" : "DESC";
+            return $"{string.Join(".", Field)}:{asc}";
+        }
     }
 }

Luticate2.Auth/Dbo/PartialObjectCopier/LuPartialObjectCopierOptions.cs

@@ -0,0 +1,7 @@
+namespace Luticate2.Auth.Dbo.PartialObjectCopier
+{
+    public class LuPartialObjectCopierOptions
+    {
+        
+    }
+}

Luticate2.Auth/Interfaces/ILuCrud.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuCrud<TDbo>
+    {
+        LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos);
+        
+        LuResult<LuPaginatedDbo<TDbo>> Read(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams);
+        
+        LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos);
+        
+        LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos);
+    }
+}

Luticate2.Auth/Interfaces/ILuFieldsExpressions.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuFieldsExpressions<TDbo, TModel>
+    {
+        LuResult<Expression<Func<TType1, object>>> GetExpression<TType1>(Expression<Func<TType1, TModel>> modelProperty, LuFieldDbo field);
+    }
+}

Luticate2.Auth/Interfaces/ILuOrderByObjectType.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Dbo.Pagination;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuOrderByObjectType<TType>
+    {
+        LuResult<IQueryable<TModel>> OrderByField<TModel, TType2>(Expression<Func<TModel, TType2>> modelProperty,
+            LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable);
+    }
+}

Luticate2.Auth/Interfaces/ILuPartialObjectCopier.cs

@@ -0,0 +1,13 @@
+using Luticate2.Auth.Dbo.Fields;
+using Luticate2.Auth.Dbo.PartialObjectCopier;
+using Luticate2.Auth.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces
+{
+    public interface ILuPartialObjectCopier<TTypeFrom, TTypeTo>
+    {
+        LuResult<TTypeTo> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options);
+
+        LuResult<TTypeTo> Copy(LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options);
+    }
+}

Luticate2.Auth/Luticate2.Auth.csproj

@@ -1,9 +1,25 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <Folder Include="Business" />
-    <Folder Include="Interfaces" />
+    <Folder Include="Business\Serializers" />
+    <Folder Include="DataAccess\Models" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="2.8.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.0" />
+    <PackageReference Include="PartialResponse.Core" Version="2.0.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.2" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+      <HintPath>..\..\..\..\.nuget\packages\newtonsoft.json\10.0.1\lib\netstandard1.3\Newtonsoft.Json.dll</HintPath>
+    </Reference>
   </ItemGroup>
 </Project>

Luticate2.Mvc.Auth.WebApiSample/Luticate2.Mvc.Auth.WebApiSample.csproj

@@ -6,7 +6,7 @@
     <Folder Include="wwwroot\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.5" />
+    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.8" />
   </ItemGroup>
   <ItemGroup>
     <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.2" />

Luticate2.Mvc.Auth/Luticate2.Mvc.Auth.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
+        <TargetFramework>netcoreapp2.0</TargetFramework>
     </PropertyGroup>
 
 </Project>

luticate2.sln.DotSettings.user

@@ -0,0 +1,35 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Fd_003AAuth_002Ff_003ALuGroupsBusiness_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Fd_003AFields_002Ff_003ALuFieldsExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Fd_003APartialObjectCopier_002Ff_003ALuPartialObjectCopier_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Fd_003APartialObjectCopier_002Ff_003ALuPartialObjectCopierGroups_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Fd_003APartialObjectCopier_002Ff_003ALuPartialObjectCopierObjectsMetadata_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ABusiness_002Ff_003ALuExpressionUtils_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ADbo_002Fd_003AAuth_002Ff_003ALuGroupDbo_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=11727D2F_002DE2EE_002D4FD5_002DBEC4_002DC22B5B0D38A2_002Fd_003ADbo_002Fd_003AAuth_002Ff_003ALuObjectsMetadata_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=65809E11_002D3C5B_002D4641_002D9710_002DE8EEF47A72E1_002Fd_003ACommands_002Ff_003AListCommand_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=65809E11_002D3C5B_002D4641_002D9710_002DE8EEF47A72E1_002Ff_003AProgram_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentBaseAttribute_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F64_003F902a0698_003FArgumentBaseAttribute_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentDefinition_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F48_003Fdae98adf_003FArgumentDefinition_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentType_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003Fd9_003F5898099c_003FArgumentType_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentValueAttribute_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F0f_003Ff70f89fc_003FArgumentValueAttribute_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentValueFlags_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003Fc5_003Fdc1a89c7_003FArgumentValueFlags_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ACollectionExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F74C8172C_002DE9D1_002D4BB9_002DBA38_002DB75C870811D2_003Fa7_003F332ae189_003FCollectionExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ACommandAttribute_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F8c_003F0f6ac0f3_003FCommandAttribute_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ACommandResult_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F05_003F1a20fe66_003FCommandResult_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ACommand_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003F60_003F54980336_003FCommand_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ADbSet_00601_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F406635BB_002DC0DC_002D4AE8_002D9B6C_002D783FB3A661DB_003F29_003Fd4a20fe1_003FDbSet_00601_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEntityFrameworkQueryableExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F406635BB_002DC0DC_002D4AE8_002D9B6C_002D783FB3A661DB_003Fc3_003Fe9584849_003FEntityFrameworkQueryableExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEnumerableExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F406635BB_002DC0DC_002D4AE8_002D9B6C_002D783FB3A661DB_003Fe6_003F156d683f_003FEnumerableExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEnumerable_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FE9E7BFFA_002D7295_002D472B_002DA90E_002D02CE460D5C59_003F63_003F8dea892b_003FEnumerable_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AExceptionDispatchInfo_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F0E1B27A4_002D6035_002D47D9_002DA041_002DCEF439F84C41_003F2e_003F9d4c8d59_003FExceptionDispatchInfo_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AExecutionTimer_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F724F386D_002D8F5B_002D4395_002DA7FA_002D46C7A3A38A2A_003Fb4_003F01ff0251_003FExecutionTimer_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AExpression_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F74C8172C_002DE9D1_002D4BB9_002DBA38_002DB75C870811D2_003F0d_003Fe5150c41_003FExpression_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AFields_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F9AE94C13_002D307D_002D4B81_002D9C49_002D042C5D639F18_003Fc1_003F78441bb9_003FFields_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AICommand_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003Fdc_003F995e2262_003FICommand_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ALoggingServiceCollectionExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F8CF7D9CF_002DDEC7_002D4909_002D9A0A_002D744E024801B5_003F5c_003Fb20d4f16_003FLoggingServiceCollectionExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AMethodBase_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F0E1B27A4_002D6035_002D47D9_002DA041_002DCEF439F84C41_003Fbd_003Ffd3a8b29_003FMethodBase_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ANamedArgumentAttribute_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003FBA7C3D01_002D2007_002D4710_002D95AB_002D341647F324E9_003Fde_003F366d7bbe_003FNamedArgumentAttribute_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AQueryable_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F711AF2B2_002DC9DB_002D4B65_002DB7EA_002DB21A353C3B37_003F39_003F53296e13_003FQueryable_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AQueryCompiler_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F406635BB_002DC0DC_002D4AE8_002D9B6C_002D783FB3A661DB_003F8f_003Fc4fa4ffe_003FQueryCompiler_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AString_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003F_002ERider2018_002E1_003Fconfig_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F0E1B27A4_002D6035_002D47D9_002DA041_002DCEF439F84C41_003Fd0_003Fedac82f9_003FString_002Ecs/@EntryIndexedValue">ForceIncluded</s:String></wpf:ResourceDictionary>