Merge pull request #53 from marcwittke/develop

marcwittke · web-flow · commit 7af451822dbc · 2018-12-30T14:56:30.000-03:00
Develop
diff --git a/src/abstractions/Backend.Fx/Exceptions/ClientException.cs b/src/abstractions/Backend.Fx/Exceptions/ClientException.cs
@@ -3,6 +3,8 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using JetBrains.Annotations;
+
 
     public class ClientException : Exception
     {
@@ -48,21 +50,28 @@ public override string ToString()
 
     public static class ClientExceptionEx
     {
-        public static TEx AddError<TEx>(this TEx clientException, string errorMessage) where TEx : ClientException
+        public static TEx AddError<TEx>(this TEx clientException, [LocalizationRequired] string errorMessage) where TEx : ClientException
         {
             clientException.Errors.Add(errorMessage);
             return clientException;
         }
 
-        public static TEx AddError<TEx>(this TEx clientException, string key, string errorMessage) where TEx : ClientException
+        public static TEx AddError<TEx>(this TEx clientException, string key, [LocalizationRequired] string errorMessage) where TEx : ClientException
         {
             clientException.Errors.Add(key, errorMessage);
             return clientException;
         }
 
-        public static TEx AddErrors<TEx>(this TEx clientException, string key, IEnumerable<string> errorMessage) where TEx : ClientException
+        public static TEx AddErrors<TEx>(this TEx clientException, [LocalizationRequired] IEnumerable<string> errorMessages) where TEx : ClientException
         {
-            clientException.Errors.Add(key, errorMessage);
+            clientException.Errors.Add(errorMessages);
+            return clientException;
+        }
+
+
+        public static TEx AddErrors<TEx>(this TEx clientException, string key, [LocalizationRequired] IEnumerable<string> errorMessages) where TEx : ClientException
+        {
+            clientException.Errors.Add(key, errorMessages);
             return clientException;
         }
     }
diff --git a/src/abstractions/Backend.Fx/Exceptions/Errors.cs b/src/abstractions/Backend.Fx/Exceptions/Errors.cs
@@ -42,6 +42,12 @@ public Errors Add(string errorMessage)
             return this;
         }
 
+        public Errors Add(IEnumerable<string> errorMessages)
+        {
+            Add(GenericErrorKey, errorMessages);
+            return this;
+        }
+
         public Errors Add(string key, IEnumerable<string> errorMessages)
         {
             if (!_dictionaryImplementation.ContainsKey(key))
diff --git a/src/environments/Backend.Fx.AspNetCore/BackendFxProgram.cs b/src/environments/Backend.Fx.AspNetCore/BackendFxProgram.cs
@@ -5,20 +5,18 @@
     using Backend.Fx.NetCore.Logging;
     using Microsoft.AspNetCore;
     using Microsoft.AspNetCore.Hosting;
-    using Microsoft.Extensions.Configuration;
-    using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
 
     public class BackendFxProgram<TStartup> where TStartup : class
     {
-        private static Logging.ILogger _logger = new DebugLogger(nameof(BackendFxProgram<TStartup>));
+        private static Backend.Fx.Logging.ILogger _logger = new DebugLogger(nameof(BackendFxProgram<TStartup>));
 
         public virtual void Main(string[] args)
         {
             IWebHost webHost;
             try
             {
-                webHost = BuildWebHost(args);
+                webHost = CreateWebHostBuilder(args).Build();
             }
             catch (Exception ex)
             {
@@ -36,13 +34,17 @@ public virtual void Main(string[] args)
             catch (Exception ex)
             {
                 _logger.Fatal(ex, "Web host died unexpectedly");
-                LogManager.Shutdown();
                 throw;
             }
+            finally
+            {
+                LogManager.Shutdown();
+            }
         }
 
-        public virtual IWebHost BuildWebHost(string[] args)
+        public IWebHostBuilder CreateWebHostBuilder(string[] args)
         {
+
             try
             {
                 _logger = LogManager.Create<BackendFxProgram<TStartup>>();
@@ -56,7 +58,6 @@ public virtual IWebHost BuildWebHost(string[] args)
 
             try
             {
-                IWebHost host;
                 using (_logger.InfoDuration("Building web host"))
                 {
                     var webHostBuilder = WebHost.CreateDefaultBuilder(args)
@@ -71,21 +72,18 @@ public virtual IWebHost BuildWebHost(string[] args)
 
                     ConfigureWebHost(webHostBuilder);
 
-                    host = webHostBuilder.Build();
-                    host.Services.GetRequiredService<IApplicationLifetime>().ApplicationStopped.Register(LogManager.Shutdown);
+                    return webHostBuilder;
                 }
-
-                return host;
             }
             catch (Exception ex)
             {
-                _logger.Fatal(ex, "Web host could not be built.");
+                _logger.Fatal(ex, "Web host builder could not be created.");
                 LogManager.Shutdown();
                 throw;
             }
         }
 
         protected virtual void ConfigureWebHost(IWebHostBuilder builder)
-        {}
+        { }
     }
 }
diff --git a/src/environments/Backend.Fx.AspNetCore/ErrorHandling/JsonErrorHandlingMiddleware.cs b/src/environments/Backend.Fx.AspNetCore/ErrorHandling/JsonErrorHandlingMiddleware.cs
@@ -17,11 +17,12 @@ public class JsonErrorHandlingMiddleware : ErrorHandlingMiddleware
     {
         private readonly IHostingEnvironment _env;
         private static readonly ILogger Logger = LogManager.Create<JsonErrorHandlingMiddleware>();
-        private readonly JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings
+
+        protected JsonSerializerSettings JsonSerializerSettings { get; } = new JsonSerializerSettings
         {
             ContractResolver = new DefaultContractResolver
             {
-                NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true }
+                NamingStrategy = new CamelCaseNamingStrategy {ProcessDictionaryKeys = true}
             },
         };
 
@@ -53,10 +54,9 @@ protected override async Task HandleClientError(HttpContext context, int httpSta
                 : new Errors().Add($"HTTP{httpStatusCode}: {message}");
 
             context.Response.StatusCode = httpStatusCode;
-            var errorsDictionaryForJson = errors.ToDictionary(kvp => kvp.Key == "" ? "_error" : kvp.Key, kvp => kvp.Value);
-            string responseContent = JsonConvert.SerializeObject(errorsDictionaryForJson, _jsonSerializerSettings);
+            string serializedErrors = SerializeErrors(errors);
             context.Response.ContentType = "application/json; charset=utf-8";
-            await context.Response.WriteAsync(responseContent);
+            await context.Response.WriteAsync(serializedErrors);
         }
 
         protected override async Task HandleServerError(HttpContext context, Exception exception)
@@ -68,10 +68,16 @@ protected override async Task HandleServerError(HttpContext context, Exception e
             }
             context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
             var responseContent = _env.IsDevelopment()
-                                          ? JsonConvert.SerializeObject(new { message = exception.Message, stackTrace = exception.StackTrace }, _jsonSerializerSettings)
-                                          : JsonConvert.SerializeObject(new { message = "An internal error occured" }, _jsonSerializerSettings);
+                                          ? JsonConvert.SerializeObject(new { message = exception.Message, stackTrace = exception.StackTrace }, JsonSerializerSettings)
+                                          : JsonConvert.SerializeObject(new { message = "An internal error occured" }, JsonSerializerSettings);
             context.Response.ContentType = "application/json; charset=utf-8";
             await context.Response.WriteAsync(responseContent);
         }
+
+        protected virtual string SerializeErrors(Errors errors)
+        {
+            var errorsDictionaryForJson = errors.ToDictionary(kvp => kvp.Key == "" ? "_error" : kvp.Key, kvp => kvp.Value);
+            return JsonConvert.SerializeObject(errorsDictionaryForJson, JsonSerializerSettings);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,8 @@`
`3`	`3`	`using System;`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Linq;`
	`6`	`+ using JetBrains.Annotations;`
	`7`	`+`
`6`	`8`
`7`	`9`	`public class ClientException : Exception`
`8`	`10`	`{`
`@@ -48,21 +50,28 @@ public override string ToString()`
`48`	`50`
`49`	`51`	`public static class ClientExceptionEx`
`50`	`52`	`{`
`51`		`- public static TEx AddError<TEx>(this TEx clientException, string errorMessage) where TEx : ClientException`
	`53`	`+ public static TEx AddError<TEx>(this TEx clientException, [LocalizationRequired] string errorMessage) where TEx : ClientException`
`52`	`54`	`{`
`53`	`55`	`clientException.Errors.Add(errorMessage);`
`54`	`56`	`return clientException;`
`55`	`57`	`}`
`56`	`58`
`57`		`- public static TEx AddError<TEx>(this TEx clientException, string key, string errorMessage) where TEx : ClientException`
	`59`	`+ public static TEx AddError<TEx>(this TEx clientException, string key, [LocalizationRequired] string errorMessage) where TEx : ClientException`
`58`	`60`	`{`
`59`	`61`	`clientException.Errors.Add(key, errorMessage);`
`60`	`62`	`return clientException;`
`61`	`63`	`}`
`62`	`64`
`63`		`- public static TEx AddErrors<TEx>(this TEx clientException, string key, IEnumerable<string> errorMessage) where TEx : ClientException`
	`65`	`+ public static TEx AddErrors<TEx>(this TEx clientException, [LocalizationRequired] IEnumerable<string> errorMessages) where TEx : ClientException`
`64`	`66`	`{`
`65`		`- clientException.Errors.Add(key, errorMessage);`
	`67`	`+ clientException.Errors.Add(errorMessages);`
	`68`	`+ return clientException;`
	`69`	`+ }`
	`70`	`+`
	`71`	`+`
	`72`	`+ public static TEx AddErrors<TEx>(this TEx clientException, string key, [LocalizationRequired] IEnumerable<string> errorMessages) where TEx : ClientException`
	`73`	`+ {`
	`74`	`+ clientException.Errors.Add(key, errorMessages);`
`66`	`75`	`return clientException;`
`67`	`76`	`}`
`68`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,12 @@ public Errors Add(string errorMessage)`
`42`	`42`	`return this;`
`43`	`43`	`}`
`44`	`44`
	`45`	`+ public Errors Add(IEnumerable<string> errorMessages)`
	`46`	`+ {`
	`47`	`+ Add(GenericErrorKey, errorMessages);`
	`48`	`+ return this;`
	`49`	`+ }`
	`50`	`+`
`45`	`51`	`public Errors Add(string key, IEnumerable<string> errorMessages)`
`46`	`52`	`{`
`47`	`53`	`if (!_dictionaryImplementation.ContainsKey(key))`
Original file line number	Diff line number	Diff line change
`@@ -5,20 +5,18 @@`
`5`	`5`	`using Backend.Fx.NetCore.Logging;`
`6`	`6`	`using Microsoft.AspNetCore;`
`7`	`7`	`using Microsoft.AspNetCore.Hosting;`
`8`		`- using Microsoft.Extensions.Configuration;`
`9`		`- using Microsoft.Extensions.DependencyInjection;`
`10`	`8`	`using Microsoft.Extensions.Logging;`
`11`	`9`
`12`	`10`	`public class BackendFxProgram<TStartup> where TStartup : class`
`13`	`11`	`{`
`14`		`- private static Logging.ILogger _logger = new DebugLogger(nameof(BackendFxProgram<TStartup>));`
	`12`	`+ private static Backend.Fx.Logging.ILogger _logger = new DebugLogger(nameof(BackendFxProgram<TStartup>));`
`15`	`13`
`16`	`14`	`public virtual void Main(string[] args)`
`17`	`15`	`{`
`18`	`16`	`IWebHost webHost;`
`19`	`17`	`try`
`20`	`18`	`{`
`21`		`- webHost = BuildWebHost(args);`
	`19`	`+ webHost = CreateWebHostBuilder(args).Build();`
`22`	`20`	`}`
`23`	`21`	`catch (Exception ex)`
`24`	`22`	`{`
`@@ -36,13 +34,17 @@ public virtual void Main(string[] args)`
`36`	`34`	`catch (Exception ex)`
`37`	`35`	`{`
`38`	`36`	`_logger.Fatal(ex, "Web host died unexpectedly");`
`39`		`- LogManager.Shutdown();`
`40`	`37`	`throw;`
`41`	`38`	`}`
	`39`	`+ finally`
	`40`	`+ {`
	`41`	`+ LogManager.Shutdown();`
	`42`	`+ }`
`42`	`43`	`}`
`43`	`44`
`44`		`- public virtual IWebHost BuildWebHost(string[] args)`
	`45`	`+ public IWebHostBuilder CreateWebHostBuilder(string[] args)`
`45`	`46`	`{`
	`47`	`+`
`46`	`48`	`try`
`47`	`49`	`{`
`48`	`50`	`_logger = LogManager.Create<BackendFxProgram<TStartup>>();`
`@@ -56,7 +58,6 @@ public virtual IWebHost BuildWebHost(string[] args)`
`56`	`58`
`57`	`59`	`try`
`58`	`60`	`{`
`59`		`- IWebHost host;`
`60`	`61`	`using (_logger.InfoDuration("Building web host"))`
`61`	`62`	`{`
`62`	`63`	`var webHostBuilder = WebHost.CreateDefaultBuilder(args)`
`@@ -71,21 +72,18 @@ public virtual IWebHost BuildWebHost(string[] args)`
`71`	`72`
`72`	`73`	`ConfigureWebHost(webHostBuilder);`
`73`	`74`
`74`		`- host = webHostBuilder.Build();`
`75`		`- host.Services.GetRequiredService<IApplicationLifetime>().ApplicationStopped.Register(LogManager.Shutdown);`
	`75`	`+ return webHostBuilder;`
`76`	`76`	`}`
`77`		`-`
`78`		`- return host;`
`79`	`77`	`}`
`80`	`78`	`catch (Exception ex)`
`81`	`79`	`{`
`82`		`- _logger.Fatal(ex, "Web host could not be built.");`
	`80`	`+ _logger.Fatal(ex, "Web host builder could not be created.");`
`83`	`81`	`LogManager.Shutdown();`
`84`	`82`	`throw;`
`85`	`83`	`}`
`86`	`84`	`}`
`87`	`85`
`88`	`86`	`protected virtual void ConfigureWebHost(IWebHostBuilder builder)`
`89`		`- {}`
	`87`	`+ { }`
`90`	`88`	`}`
`91`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,12 @@ public class JsonErrorHandlingMiddleware : ErrorHandlingMiddleware`
`17`	`17`	`{`
`18`	`18`	`private readonly IHostingEnvironment _env;`
`19`	`19`	`private static readonly ILogger Logger = LogManager.Create<JsonErrorHandlingMiddleware>();`
`20`		`- private readonly JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings`
	`20`	`+`
	`21`	`+ protected JsonSerializerSettings JsonSerializerSettings { get; } = new JsonSerializerSettings`
`21`	`22`	`{`
`22`	`23`	`ContractResolver = new DefaultContractResolver`
`23`	`24`	`{`
`24`		`- NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true }`
	`25`	`+ NamingStrategy = new CamelCaseNamingStrategy {ProcessDictionaryKeys = true}`
`25`	`26`	`},`
`26`	`27`	`};`
`27`	`28`
`@@ -53,10 +54,9 @@ protected override async Task HandleClientError(HttpContext context, int httpSta`
`53`	`54`	`: new Errors().Add($"HTTP{httpStatusCode}: {message}");`
`54`	`55`
`55`	`56`	`context.Response.StatusCode = httpStatusCode;`
`56`		`- var errorsDictionaryForJson = errors.ToDictionary(kvp => kvp.Key == "" ? "_error" : kvp.Key, kvp => kvp.Value);`
`57`		`- string responseContent = JsonConvert.SerializeObject(errorsDictionaryForJson, _jsonSerializerSettings);`
	`57`	`+ string serializedErrors = SerializeErrors(errors);`
`58`	`58`	`context.Response.ContentType = "application/json; charset=utf-8";`
`59`		`- await context.Response.WriteAsync(responseContent);`
	`59`	`+ await context.Response.WriteAsync(serializedErrors);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`protected override async Task HandleServerError(HttpContext context, Exception exception)`
`@@ -68,10 +68,16 @@ protected override async Task HandleServerError(HttpContext context, Exception e`
`68`	`68`	`}`
`69`	`69`	`context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;`
`70`	`70`	`var responseContent = _env.IsDevelopment()`
`71`		`- ? JsonConvert.SerializeObject(new { message = exception.Message, stackTrace = exception.StackTrace }, _jsonSerializerSettings)`
`72`		`- : JsonConvert.SerializeObject(new { message = "An internal error occured" }, _jsonSerializerSettings);`
	`71`	`+ ? JsonConvert.SerializeObject(new { message = exception.Message, stackTrace = exception.StackTrace }, JsonSerializerSettings)`
	`72`	`+ : JsonConvert.SerializeObject(new { message = "An internal error occured" }, JsonSerializerSettings);`
`73`	`73`	`context.Response.ContentType = "application/json; charset=utf-8";`
`74`	`74`	`await context.Response.WriteAsync(responseContent);`
`75`	`75`	`}`
	`76`	`+`
	`77`	`+ protected virtual string SerializeErrors(Errors errors)`
	`78`	`+ {`
	`79`	`+ var errorsDictionaryForJson = errors.ToDictionary(kvp => kvp.Key == "" ? "_error" : kvp.Key, kvp => kvp.Value);`
	`80`	`+ return JsonConvert.SerializeObject(errorsDictionaryForJson, JsonSerializerSettings);`
	`81`	`+ }`
`76`	`82`	`}`
`77`	`83`	`}`