extensoins

Author: KSemenenko

ManagedCode.Communication.Extensions/Extensions/HubOptionsExtensions.cs

@@ -10,7 +10,7 @@ public static class HubOptionsExtensions
 {
     public static void AddCommunicationHubFilter(this HubOptions result, IServiceProvider serviceProvider)
     {
-        var hubFilter = serviceProvider.GetRequiredService<HubExceptionFilterBase>();
+        var hubFilter = serviceProvider.GetRequiredService<CommunicationHubExceptionFilter>();
         result.AddFilter(hubFilter);
     }
 }

ManagedCode.Communication.Extensions/Extensions/ServiceCollectionExtensions.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using ManagedCode.Communication.Extensions.Filters;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -58,29 +59,29 @@ public static IServiceCollection AddDefaultProblemDetails(this IServiceCollectio
         return services;
     }
 
-    public static IServiceCollection AddCommunicationFilters<TExceptionFilter, TModelValidationFilter, THubExceptionFilter>(
-        this IServiceCollection services)
-        where TExceptionFilter : ExceptionFilterBase
-        where TModelValidationFilter : ModelValidationFilterBase
-        where THubExceptionFilter : HubExceptionFilterBase
+    public static IServiceCollection AddCommunicationFilters(this IServiceCollection services)
     {
-        services.AddScoped<TExceptionFilter>();
-        services.AddScoped<TModelValidationFilter>();
-        services.AddScoped<THubExceptionFilter>();
+        services.AddScoped<CommunicationExceptionFilter>();
+        services.AddScoped<CommunicationModelValidationFilter>();
+        services.AddScoped<CommunicationHubExceptionFilter>();
         services.AddScoped<ResultToActionResultFilter>();
 
-        services.AddControllers(options => 
-        { 
-            options.Filters.Add<TExceptionFilter>();
-            options.Filters.Add<TModelValidationFilter>();
-            options.Filters.Add<ResultToActionResultFilter>();
-        });
-
-        services.Configure<HubOptions>(options =>
-        {
-            options.AddFilter<THubExceptionFilter>();
-        });
-
         return services;
     }
+    
+    public static MvcOptions AddCommunicationFilters(this MvcOptions options)
+    {
+        options.Filters.Add<CommunicationExceptionFilter>();
+        options.Filters.Add<CommunicationModelValidationFilter>();
+        options.Filters.Add<ResultToActionResultFilter>();
+        
+        return options;
+    }
+    
+    public static HubOptions AddCommunicationFilters(this HubOptions options)
+    {
+        options.AddFilter<CommunicationHubExceptionFilter>();
+        
+        return options;
+    }
 }

…xtensions/Filters/ExceptionFilterBase.cs …/Filters/CommunicationExceptionFilter.csManagedCode.Communication.Extensions/Filters/ExceptionFilterBase.cs renamed to ManagedCode.Communication.Extensions/Filters/CommunicationExceptionFilter.cs ManagedCode.Communication.Extensions/Filters/ExceptionFilterBase.cs renamed to ManagedCode.Communication.Extensions/Filters/CommunicationExceptionFilter.cs

@@ -8,7 +8,7 @@
 
 namespace ManagedCode.Communication.Extensions.Filters;
 
-public abstract class ExceptionFilterBase(ILogger logger) : IExceptionFilter
+public class CommunicationExceptionFilter(ILogger<CommunicationExceptionFilter> logger) : IExceptionFilter
 {
     public virtual void OnException(ExceptionContext context)
     {
@@ -22,20 +22,7 @@ public virtual void OnException(ExceptionContext context)
                 controllerName, actionName);
 
             var statusCode = GetStatusCodeForException(exception);
-            
-            var problem = new Problem()
-            {
-                Title = exception.GetType().Name,
-                Detail = exception.Message,
-                StatusCode = (int)statusCode,
-                Instance = context.HttpContext.Request.Path,
-                Extensions =
-                {
-                    [ExtensionKeys.TraceId] = context.HttpContext.TraceIdentifier
-                }
-            };
-            
-            var result = Result.Fail(problem);
+            var result = Result.Fail(exception, statusCode);
 
             context.Result = new ObjectResult(result)
             {
@@ -51,14 +38,7 @@ public virtual void OnException(ExceptionContext context)
         {
             logger.LogError(ex, "Error occurred while handling exception in {FilterType}", GetType().Name);
 
-            var fallbackProblem = new Problem
-            {
-                Title = Titles.UnexpectedError,
-                StatusCode = (int)HttpStatusCode.InternalServerError,
-                Instance = context.HttpContext.Request.Path
-            };
-            
-            context.Result = new ObjectResult(Result.Fail(fallbackProblem))
+            context.Result = new ObjectResult(Result.Fail(Titles.UnexpectedError, ex.Message, HttpStatusCode.InternalServerError))
             {
                 StatusCode = (int)HttpStatusCode.InternalServerError
             };

ManagedCode.Communication.Extensions/Filters/CommunicationHubExceptionFilter.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.Logging;
+using static ManagedCode.Communication.Extensions.Helpers.HttpStatusCodeHelper;
+using static ManagedCode.Communication.Extensions.Constants.ProblemConstants;
+
+namespace ManagedCode.Communication.Extensions.Filters;
+
+public class CommunicationHubExceptionFilter(ILogger<CommunicationHubExceptionFilter> logger) : IHubFilter
+{
+    public async ValueTask<object?> InvokeMethodAsync(HubInvocationContext invocationContext,
+        Func<HubInvocationContext, ValueTask<object?>> next)
+    {
+        try
+        {
+            return await next(invocationContext);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Unhandled exception in hub method {HubType}.{HubMethod}", 
+                invocationContext.Hub.GetType().Name, invocationContext.HubMethodName);
+
+            var statusCode = GetStatusCodeForException(ex);
+            return ManagedCode.Communication.Result.Fail(ex, statusCode);
+        }
+    }
+} 

ManagedCode.Communication.Extensions/Filters/CommunicationModelValidationFilter.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using System.Net;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+using static ManagedCode.Communication.Extensions.Constants.ProblemConstants;
+
+namespace ManagedCode.Communication.Extensions.Filters;
+
+public class CommunicationModelValidationFilter(ILogger<CommunicationModelValidationFilter> logger) : IActionFilter
+{
+
+    public void OnActionExecuting(ActionExecutingContext context)
+    {
+        if (!context.ModelState.IsValid)
+        {
+            logger.LogWarning("Model validation failed for {ActionName}", 
+                context.ActionDescriptor.DisplayName);
+
+            var validationErrors = context.ModelState
+                .Where(x => x.Value?.Errors.Count > 0)
+                .SelectMany(x => x.Value!.Errors.Select(e => (x.Key, e.ErrorMessage)))
+                .ToArray();
+
+            var result = ManagedCode.Communication.Result.FailValidation(validationErrors);
+
+            context.Result = new BadRequestObjectResult(result);
+        }
+    }
+
+    public void OnActionExecuted(ActionExecutedContext context)
+    {
+        // Not needed for this filter
+    }
+} 

ManagedCode.Communication.Extensions/Filters/HubExceptionFilterBase.cs

@@ -22,9 +22,16 @@ public static void Main(string[] args)
 
         builder.Services.AddAuthorization();
 
-        builder.Services.AddCommunicationFilters<TestExceptionFilter, TestModelValidationFilter, TestHubExceptionFilter>();
-        builder.Services.AddSignalR(options => 
+        builder.Services.AddCommunicationFilters();
+        
+        builder.Services.AddControllers(options => 
+        {
+            options.AddCommunicationFilters();
+        });
+        
+        builder.Services.AddSignalR(options =>
         {
+            options.AddCommunicationFilters();
         });