fixes; TODO

Luticate2.Auth/Controllers/LuAuthExtensions.cs

             builder.AddLuticatUtils();
 //            builder.AddApplicationPart(typeof(LuController).GetTypeInfo().Assembly)
 //                .AddControllersAsServices();
-            builder.Services.Configure<MvcOptions>(
-                options => options.ModelBinderProviders.Insert(0, new LuOrderByBinderProvider()));
             return builder;
         }
 

Luticate2.Utils/Business/LuCrudBusiness.cs

 using System;
 using System.Collections.Generic;
-using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
             return LuResult<TDboUpdate>.Ok(update);
         }
 
-        protected virtual LuResult<TDboRead> CheckGet(TDboRead obj)
-        {
-            return LuResult<TDboRead>.Ok(obj);
-        }
-
-        protected virtual LuResult<TDboRead> CheckDelete(TDboRead obj)
-        {
-            return LuResult<TDboRead>.Ok(obj);
-        }
-
         protected LuResult<TDboUpdate> GetAndCheckEdit(string id, TDboUpdate update)
         {
             var res = GetSingleById(id);
             return CheckEdit(res.Data, update);
         }
 
-        protected LuResult<TDboRead> GetAndCheckGet(string id)
-        {
-            var res = GetSingleById(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
-            return CheckGet(res.Data);
-        }
-
-        protected LuResult<TDboRead> GetAndCheckGet(long id)
-        {
-            var res = GetSingleById(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
-            return CheckGet(res.Data);
-        }
-
-        protected LuResult<TDboRead> GetAndCheckDelete(string id)
-        {
-            var res = GetSingleById(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
-            return CheckDelete(res.Data);
-        }
-
-        protected LuResult<TDboRead> GetAndCheckDelete(long id)
-        {
-            var res = GetSingleById(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
-            return CheckDelete(res.Data);
-        }
 
 
 
 
         public LuResult<TDboRead> GetSingleById(string id)
         {
-            var res = GetAndCheckGet(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
             return DataAccess.GetSingleById(id);
         }
 
         public LuResult<TDboRead> GetSingleById(long id)
         {
-            var res = GetAndCheckGet(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
             return DataAccess.GetSingleById(id);
         }
 
 
         public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<T>();
-            }
             return DataAccess.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<string> DeleteSingleByIdGuid(string id)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<string>();
-            }
             return DataAccess.DeleteSingleByIdGuid(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(string id)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
             return DataAccess.DeleteSingleByIdDbo(id);
         }
 
         public LuResult<T> DeleteSingleById<T>(long id, Func<TDboRead, T> returnFunc)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<T>();
-            }
             return DataAccess.DeleteSingleById(id, returnFunc);
         }
 
         public LuResult<long> DeleteSingleByIdId(long id)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<long>();
-            }
             return DataAccess.DeleteSingleByIdId(id);
         }
 
         public LuResult<TDboRead> DeleteSingleByIdDbo(long id)
         {
-            var res = GetAndCheckDelete(id);
-            if (!res)
-            {
-                return res.To<TDboRead>();
-            }
             return DataAccess.DeleteSingleByIdDbo(id);
         }
     }

Luticate2.Utils/Controllers/LuController.cs

             {
                 return new LuApiWrapperDbo<T>
                 {
-                    Code = 200,
-                    Data = result.Data,
-                    Message = null
+                    code = 200,
+                    data = result.Data,
+                    message = null
                 };
             }
             throw new LuResultException(result.To<object>());

Luticate2.Utils/Controllers/LuCrudController.cs

-using Luticate2.Utils.Dbo;
+using System;
+using System.Linq;
+using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 
         [HttpPost]
         [Route("[controller]")]
-        public LuApiWrapperDbo<TDboRead> Add([FromBody]TDboCreate data)
+        public LuApiWrapperDbo<TDboRead> AddDbo([FromBody]TDboCreate data)
         {
             return Handle(Busines.AddDbo(data));
         }
 
         [HttpPost]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> Edit(string id, [FromBody]TDboUpdate data)
+        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo(string id, [FromBody]TDboUpdate data)
         {
             return Handle(Busines.EditSingleByIdDbo(id, data));
         }

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

 using System.Collections.Generic;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Middlewares;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Luticate2.Utils.Controllers
 
         public static IMvcBuilder AddLuticatUtils(this IMvcBuilder builder)
         {
+            builder.Services.Configure<MvcOptions>(
+                options => options.ModelBinderProviders.Insert(0, new LuOrderByBinderProvider()));
             return builder;
         }
 
         public static IApplicationBuilder UseLuticateUtils(this IApplicationBuilder app)
         {
-//            app.UseMiddleware<LuAuthMiddleware>();
             app.UseMiddleware<LuExceptionMiddleware>();
             return app;
         }

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

             return model;
         }
 
-        protected Guid GetGuid(string id)
+        protected Guid? GetGuid(string id)
         {
             Guid guid;
             if (Guid.TryParse(id, out guid))
             {
                 return guid;
             }
-            return new Guid();
+            return null;
+        }
+
+        protected LuResult<T> GetNotFoundResult<T>()
+        {
+            return LuResult<T>.Error(LuStatus.NotFound, typeof(TModel).Name + ": Value not found", "");
         }
 
 
             return Execute(() =>
             {
                 var model = Table.FirstOrDefault(predicate);
-                if (model == null)
+                if (model == default(TModel))
                 {
-                    return LuResult<TDboRead>.Error(LuStatus.NotFound, typeof(TModel).Name + ": Value not found", "");
+                    return GetNotFoundResult<TDboRead>();
                 }
                 var dbo = GetDboFromModel(model);
                 return LuResult<TDboRead>.Ok(dbo);
 
         public LuResult<TDboRead> GetSingleById(string id)
         {
-            return GetSingleByKeys(new KeyValuePair<string, object>("id", GetGuid(id)));
+            var guid = GetGuid(id);
+            if (guid == null)
+            {
+                return GetNotFoundResult<TDboRead>();
+            }
+            return GetSingleByKeys(new KeyValuePair<string, object>("id", guid));
         }
 
         public LuResult<TDboRead> GetSingleById(long id)
 
         public LuResult<T> EditSingleById<T>(string id, Action<TModel> update, Func<TDboRead, T> returnFunc)
         {
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))), update,
+            var guid = GetGuid(id);
+            if (guid == null)
+            {
+                return GetNotFoundResult<T>();
+            }
+            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)), update,
                 list => returnFunc(list.FirstOrDefault()));
         }
 
 
         public LuResult<T> EditSingleById<T>(string id, TDboUpdate update, Func<TDboRead, T> returnFunc)
         {
-            return Edit(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))),
+            var guid = GetGuid(id);
+            if (guid == null)
+            {
+                return GetNotFoundResult<T>();
+            }
+            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)),
                 model => EditModelFromTUpdate(update, model), list => returnFunc(list.FirstOrDefault()));
         }
 
 
         public LuResult<T> DeleteSingleById<T>(string id, Func<TDboRead, T> returnFunc)
         {
-            return Delete(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))),
-                reads => returnFunc(reads.First()));
+            var guid = GetGuid(id);
+            if (guid == null)
+            {
+                return GetNotFoundResult<T>();
+            }
+            return Delete(GetExpression(new KeyValuePair<string, object>("id", guid)),
+                reads => returnFunc(reads.FirstOrDefault()));
         }
 
         public LuResult<string> DeleteSingleByIdGuid(string id)

Luticate2.Utils/Dbo/Basic/LuApiWrapperDbo.cs

 {
     public class LuApiWrapperDbo<T>
     {
-        public int Code { get; set; }
+        public int code { get; set; }
 
-        public string Message { get; set; }
+        public string message { get; set; }
 
-        public T Data { get; set; }
+        public T data { get; set; }
     }
 }

Luticate2.Utils/Middlewares/LuExceptionMiddleware.cs

 using System;
+using System.Buffers;
 using System.Threading.Tasks;
 using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.Basic;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
 using Newtonsoft.Json;
 
     {
         private readonly RequestDelegate _next;
 
-        public LuExceptionMiddleware(RequestDelegate next,
-            IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
+        public LuExceptionMiddleware(RequestDelegate next)
         {
             _next = next;
         }
                 response.StatusCode = e.Result.GetHttpCode();
                 await response.WriteAsync(JsonConvert.SerializeObject(new LuApiWrapperDbo<object>
                 {
-                    Code = e.Result.GetHttpCode(),
-                    Data = null,
-                    Message = e.Result.PublicDetails
+                    code = e.Result.GetHttpCode(),
+                    data = null,
+                    message = e.Result.PublicDetails
                 })).ConfigureAwait(false);
             }
             catch (Exception e)//TODO
                 response.StatusCode = 500;
                 await response.WriteAsync(JsonConvert.SerializeObject(new LuApiWrapperDbo<object>
                 {
-                    Code = 500,
-                    Data = null,
-                    Message = "Internal Error"
+                    code = 500,
+                    data = null,
+                    message = "Internal Error"
                 })).ConfigureAwait(false);
             }
         }

TODO

+fix crud business checks
 websockets
 authentication filter
 filter dbo