refactor; handle(single) methods; exception handler; lu result handling

Luticate2.Auth/Controllers/LuticateExtensions.cs → Luticate2.Auth/Controllers/LuAuthExtensions.cs

 
 namespace Luticate2.Auth.Controllers
 {
-    public static class LuticateExtensions
+    public static class LuAuthExtensions
     {
-        public static IServiceCollection AddLuticate(this IServiceCollection services)
+        public static IServiceCollection AddLuticateAuth(this IServiceCollection services)
         {
+            services.AddLuticatUtils();
+
             services.AddSingleton<LuGroupsController>();
             services.AddSingleton<LuGroupsBusiness>();
             services.AddSingleton<LuGroupsDataAccess>();
             return services;
         }
 
-        public static IMvcBuilder AddLuticate(this IMvcBuilder builder)
+        public static IMvcBuilder AddLuticateAuth(this IMvcBuilder builder)
         {
+            builder.AddLuticatUtils();
 //            builder.AddApplicationPart(typeof(LuController).GetTypeInfo().Assembly)
 //                .AddControllersAsServices();
             builder.Services.Configure<MvcOptions>(
             return builder;
         }
 
-        public static IApplicationBuilder UseLuticate(this IApplicationBuilder app)
+        public static IApplicationBuilder UseLuticateAuth(this IApplicationBuilder app)
         {
+            app.UseLuticateUtils();
             app.UseMiddleware<LuAuthMiddleware>();
             return app;
         }

Luticate2.Auth/Dbo/Groups/LuGroupsAddDbo.cs

 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
 
 namespace Luticate2.Auth.Dbo.Groups
 {

Luticate2.Auth/Dbo/Groups/LuGroupsDbo.cs

 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
 
 namespace Luticate2.Auth.Dbo.Groups
 {

Luticate2.Auth/Dbo/Users/UsersDbo.cs

 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
 
 namespace Luticate2.Auth.Dbo.Users
 {

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;
 using Luticate2.Utils.Interfaces;
 
 namespace Luticate2.Utils.Business

Luticate2.Utils/Controllers/LuController.cs

 using System.Collections.Generic;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Result;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SignalR.Infrastructure;
 
 
         protected IDictionary<object, object> LuItems => HttpContext.GetLuItems();
 
-        protected T Handle<T>(LuResult<T> result)
+        protected LuApiWrapperDbo<T> Handle<T>(LuResult<T> result)
         {
             if (result)
             {
-                return result.Data;
+                return new LuApiWrapperDbo<T>
+                {
+                    Code = 200,
+                    Data = result.Data,
+                    Message = null
+                };
             }
-            return default(T);//TODO
+            throw new LuResultException(result.To<object>());
+        }
+
+        protected LuApiWrapperDbo<LuBoxedValueDbo<T>> HandleBoxed<T>(LuResult<T> result)
+        {
+            return Handle(result.To(arg => new LuBoxedValueDbo<T>
+            {
+                Value = arg
+            }));
         }
     }
 }

Luticate2.Utils/Controllers/LuCrudController.cs

 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
 namespace Luticate2.Utils.Controllers
 {
-    public abstract class LuCrudController<TDboCreate, TDboRead, TDboUpdate> : LuController
+    public abstract class LuCrudController<TBusiness, TDboCreate, TDboRead, TDboUpdate> : LuController
         where TDboCreate : class
         where TDboRead : class
         where TDboUpdate : class
+        where TBusiness : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate>
     {
-        protected readonly ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate> Busines;
+        protected readonly TBusiness Busines;
 
-        protected LuCrudController(ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate> busines)
+        protected LuCrudController(TBusiness busines)
         {
             Busines = busines;
         }
 
         [HttpGet]
         [Route("[controller]/{id}")]
-        public TDboRead GetSingleById(string id)
+        public LuApiWrapperDbo<TDboRead> GetSingleById(string id)
         {
             return Handle(Busines.GetSingleById(id));
         }
 
         [HttpGet]
         [Route("[controller]")]
-        public LuPaginatedDbo<TDboRead> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
         {
             return Handle(Busines.GetMultiple(orderBy, page, perPage));
         }
 
         [HttpPost]
         [Route("[controller]")]
-        public TDboRead Add([FromBody]TDboCreate data)
+        public LuApiWrapperDbo<TDboRead> Add([FromBody]TDboCreate data)
         {
             return Handle(Busines.AddDbo(data));
         }
 
         [HttpPost]
         [Route("[controller]/{id}")]
-        public TDboRead Edit(string id, [FromBody]TDboUpdate data)
+        public LuApiWrapperDbo<TDboRead> Edit(string id, [FromBody]TDboUpdate data)
         {
             return Handle(Busines.EditSingleByIdDbo(id, data));
         }
 
         [HttpDelete]
         [Route("[controller]/{id}")]
-        public TDboRead Delete(string id)
+        public LuApiWrapperDbo<TDboRead> Delete(string id)
         {
             return Handle(Busines.DeleteSingleByIdDbo(id));
         }

Luticate2.Utils/Controllers/LuResultException.cs

+using System;
+using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
+
+namespace Luticate2.Utils.Controllers
+{
+    public class LuResultException : Exception
+    {
+        public LuResult<object> Result { get; set; }
+
+        public LuResultException(LuResult<object> result) : base(result.PrivateDetails, result.Exception)
+        {
+            Result = result;
+        }
+    }
+}

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

 using System.Collections.Generic;
+using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Middlewares;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Luticate2.Utils.Controllers
 {
-    public static class LuControllerUtilsExtensions
+    public static class LuUtilsExtensions
     {
+        public static IServiceCollection AddLuticatUtils(this IServiceCollection services)
+        {
+
+            return services;
+        }
+
+        public static IMvcBuilder AddLuticatUtils(this IMvcBuilder builder)
+        {
+            return builder;
+        }
+
+        public static IApplicationBuilder UseLuticateUtils(this IApplicationBuilder app)
+        {
+//            app.UseMiddleware<LuAuthMiddleware>();
+            app.UseMiddleware<LuExceptionMiddleware>();
+            return app;
+        }
+
+        public static int GetHttpCode<T>(this LuResult<T> result)
+        {
+            if (result.Status == LuStatus.Success)
+            {
+                return 200;
+            }
+            if (result.Status == LuStatus.InputError)
+            {
+                return 400;
+            }
+            if (result.Status == LuStatus.LoginError)
+            {
+                return 401;
+            }
+            if (result.Status == LuStatus.PermissionError)
+            {
+                return 403;
+            }
+            if (result.Status == LuStatus.NotFound)
+            {
+                return 404;
+            }
+            if (result.Status == LuStatus.DbError)
+            {
+                return 500;
+            }
+            if (result.Status == LuStatus.InternalError)
+            {
+                return 500;
+            }
+            return 418;
+        }
+
         public static IDictionary<object, object> GetLuItems(this HttpContext context)
         {
             return (IDictionary<object, object>) context.Items["luticateItems"];

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

 using System.Linq.Expressions;
 using System.Reflection;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Utils;
 using Microsoft.EntityFrameworkCore;
             return model;
         }
 
+        protected Guid GetGuid(string id)
+        {
+            Guid guid;
+            if (Guid.TryParse(id, out guid))
+            {
+                return guid;
+            }
+            return new Guid();
+        }
+
 
 
 
 
         public LuResult<TDboRead> GetSingleById(string id)
         {
-            return GetSingleByKeys(new KeyValuePair<string, object>("id", new Guid(id)));
+            return GetSingleByKeys(new KeyValuePair<string, object>("id", GetGuid(id)));
         }
 
         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", new Guid(id))), update,
+            return Edit(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))), 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", new Guid(id))),
+            return Edit(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))),
                 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", new Guid(id))),
+            return Delete(GetExpression(new KeyValuePair<string, object>("id", GetGuid(id))),
                 reads => returnFunc(reads.First()));
         }
 

Luticate2.Utils/DataAccess/LuEfDataAccess.cs

 using System.Collections.Generic;
 using System.Linq.Expressions;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
 using Microsoft.EntityFrameworkCore;
 
 namespace Luticate2.Utils.DataAccess

Luticate2.Utils/Dbo/Basic/LuApiWrapperDbo.cs

+namespace Luticate2.Utils.Dbo.Basic
+{
+    public class LuApiWrapperDbo<T>
+    {
+        public int Code { get; set; }
+
+        public string Message { get; set; }
+
+        public T Data { get; set; }
+    }
+}

Luticate2.Utils/Dbo/Basic/LuBoxedValueDbo.cs

-namespace Luticate2.Utils.Dbo
+namespace Luticate2.Utils.Dbo.Basic
 {
     public class LuBoxedValueDbo<T> : LuDbo
     {

Luticate2.Utils/Dbo/Basic/LuDbo.cs

-namespace Luticate2.Utils.Dbo
+namespace Luticate2.Utils.Dbo.Basic
 {
     public class LuDbo
     {

Luticate2.Utils/Dbo/Basic/LuPaginatedDbo.cs

 using System.Collections.Generic;
 
-namespace Luticate2.Utils.Dbo
+namespace Luticate2.Utils.Dbo.Basic
 {
     public class LuPaginatedDbo<TDbo> : LuDbo
     {

Luticate2.Utils/Dbo/OrderBy/LuOrderByBinder.cs

 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Luticate2.Utils.Dbo.Result;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 
 namespace Luticate2.Utils.Dbo.OrderBy

Luticate2.Utils/Dbo/Result/LuResult.cs

 using System;
 
-namespace Luticate2.Utils.Dbo
+namespace Luticate2.Utils.Dbo.Result
 {
     public class LuResult<T>
     {

Luticate2.Utils/Dbo/Result/LuStatus.cs

-namespace Luticate2.Utils.Dbo
+namespace Luticate2.Utils.Dbo.Result
 {
     public enum LuStatus
     {

Luticate2.Utils/Interfaces/ILuCrudInterface.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;
 
 namespace Luticate2.Utils.Interfaces
 {

Luticate2.Utils/Middlewares/LuExceptionMiddleware.cs

+using System;
+using System.Threading.Tasks;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Basic;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Newtonsoft.Json;
+
+namespace Luticate2.Utils.Middlewares
+{
+    public class LuExceptionMiddleware
+    {
+        private readonly RequestDelegate _next;
+
+        public LuExceptionMiddleware(RequestDelegate next,
+            IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
+        {
+            _next = next;
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            try
+            {
+                await _next.Invoke(context);
+            }
+            catch (LuResultException e)
+            {
+                var response = context.Response;
+                response.ContentType = "application/json";
+                response.StatusCode = e.Result.GetHttpCode();
+                await response.WriteAsync(JsonConvert.SerializeObject(new LuApiWrapperDbo<object>
+                {
+                    Code = e.Result.GetHttpCode(),
+                    Data = null,
+                    Message = e.Result.PublicDetails
+                })).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                var response = context.Response;
+                response.ContentType = "application/json";
+                response.StatusCode = 500;
+                await response.WriteAsync(JsonConvert.SerializeObject(new LuApiWrapperDbo<object>
+                {
+                    Code = 500,
+                    Data = null,
+                    Message = "Internal Error"
+                })).ConfigureAwait(false);
+            }
+        }
+    }
+}

Luticate2.Utils/Utils/LuUtilsExtension.cs → Luticate2.Utils/Utils/LuCoreUtilsExtensions.cs

 
 namespace Luticate2.Utils.Utils
 {
-    public static class LuUtilsExtension
+    public static class LuCoreUtilsExtensions
     {
         public static string ToSnakeCase(this string str)
         {

Test/Utils/Binders/LuOrderByBinderTest.cs

 using System.Linq;
 using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.Result;
 using Xunit;
 
 namespace Test.Utils.Binders

Test/Utils/EfCrudDataAccess/LuEfCreateDataAccessTest.cs

 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkBigSerial;
 using Test.Utils.Dbo.PkGuid;

Test/Utils/EfCrudDataAccess/LuEfDeleteDataAccessTest.cs

 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkBigSerial;
 using Test.Utils.Dbo.PkGuid;

Test/Utils/EfCrudDataAccess/LuEfReadDataAccessTest.cs

 using System.Linq;
 using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.Result;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkBigSerial;
 using Test.Utils.Dbo.PkGuid;

Test/Utils/EfCrudDataAccess/LuEfUpdateDataAccessTest.cs

 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkBigSerial;
 using Test.Utils.Dbo.PkGuid;

WebTest/Business/PkGuidBusiness.cs

 using Luticate2.Utils.Business;
 using Luticate2.Utils.Dbo;
+using Luticate2.Utils.Dbo.Result;
 using Test.Utils.DataAccess;
 using Test.Utils.Dbo.PkGuid;
 

WebTest/Controllers/PkGuidController.cs

 
 namespace WebTest.Controllers
 {
-    public class PkGuidController : LuCrudController<PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
+    public class PkGuidController : LuCrudController<PkGuidBusiness, PkGuidAddDbo, PkGuidDbo, PkGuidAddDbo>
     {
         public PkGuidController(PkGuidBusiness busines) : base(busines)
         {

WebTest/Startup.cs

             // Add framework services.
             services.AddApplicationInsightsTelemetry(Configuration);
 
-            services.AddLuticate();
+            services.AddLuticateAuth();
 
             services.AddSingleton<PkGuidBusiness>();
             services.AddSingleton<LuUtilsPkGuidDataAccess>();
             services.AddDbContext<LuUtilsDbContext>(options => options.UseNpgsql(Tests.ConnectionString));
 
             services.AddMvc()
-                .AddLuticate();
+                .AddLuticateAuth();
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
 
             app.UseApplicationInsightsExceptionTelemetry();
 
-            app.UseLuticate();
+            app.UseLuticateAuth();
 
             app.UseMvc();
         }