Add Validation Pipeline and CustomExceptions.

src/SwiftLink.Application/Behaviors/ValidationBehavior.cs

@@ -1,47 +1,35 @@
-using Azure;
-using FluentValidation;
+using FluentValidation;
 using MediatR;
-using System.Net;
+using SwiftLink.Application.Common;
+using SwiftLink.Application.Common.Exceptions;
 
 namespace SwiftLink.Application.Behaviors;
 
-/// <summary>
-/// Pipie line for Validation.
-/// </summary>
-/// <typeparam name="TRequest"></typeparam>
-/// <typeparam name="TResult"></typeparam>
-public class ValidationBehavior<TRequest, TResult>(IEnumerable<IValidator<TRequest>> validators)
-    : IPipelineBehavior<TRequest, TResult> where TRequest : notnull
+public sealed class ValidationBehavior<TRequest, TResponse>(IEnumerable<IValidator<TRequest>> validators)
+    : IPipelineBehavior<TRequest, TResponse>
 {
     private readonly IEnumerable<IValidator<TRequest>> _validators = validators;
-
-    public async Task<TResult> Handle(TRequest request, RequestHandlerDelegate<TResult> next,
-        CancellationToken ct = default)
+    public async Task<TResponse> Handle(
+        TRequest request,
+        RequestHandlerDelegate<TResponse> next,
+        CancellationToken cancellationToken)
     {
-        if (!_validators.Any())
-            return await next();
-
-        var validationContext = new ValidationContext<TRequest>(request);
-
-        var validationResults = await Task.WhenAll(_validators.Select(v => v.ValidateAsync(validationContext, ct)));
+        var context = new ValidationContext<TRequest>(request);
 
-        var errorList = validationResults.Where(r => r.Errors.Count != 0)
-                                         .SelectMany(x => x.Errors)
-                                         .ToList();
+        var validationFailures = await Task.WhenAll(_validators.Select(validator => validator.ValidateAsync(context)));
 
-        if (errorList.Count > 0)
-        {
-            var message = string.Join(" | ", errorList.Select(e => e.ErrorMessage));
+        var errors = validationFailures
+            .Where(validationResult => !validationResult.IsValid)
+            .SelectMany(validationResult => validationResult.Errors)
+            .Select(validationFailure => new ValidationError(
+                validationFailure.PropertyName,
+                validationFailure.ErrorMessage))
+            .ToList();
 
-            if (Enum.TryParse(errorList.First().ErrorCode, out HttpStatusCode statusCode))
-                return GenerateResponse(message, statusCode);
+        if (errors.Count != 0)
+            throw new BusinessValidationException(errors);
 
-            return GenerateResponse(message);
-        }
-
-        return await next();
+        var response = await next();
+        return response;
     }
-
-    private static TResult GenerateResponse(string message, HttpStatusCode statusCode = HttpStatusCode.BadRequest)
-       => (TResult)Activator.CreateInstance(typeof(Result<object>), false, message, statusCode);
-}
+}

src/SwiftLink.Application/Common/Exceptions/BusinessValidationException.cs

@@ -0,0 +1,5 @@
+namespace SwiftLink.Application.Common.Exceptions;
+public class BusinessValidationException(List<ValidationError> errors) : Exception
+{
+    public readonly List<ValidationError> Errors = errors;
+}

src/SwiftLink.Application/Common/ValidationError.cs

@@ -0,0 +1,2 @@
+namespace SwiftLink.Application.Common;
+public record ValidationError(string PropertyName, string ErrorMessage);

src/SwiftLink.Application/UseCases/Links/Commands/GenerateShortCode/GenerateShortCodeCommandHandler.cs

@@ -19,6 +19,7 @@ public class GenerateShortCodeCommandHandler(IApplicationDbContext dbContext,
 
     public async Task<Result<object>> Handle(GenerateShortCodeCommand request, CancellationToken cancellationToken = default)
     {
+        var subscriber = _dbContext.Set<Subscriber>().Find(request.Token);
         var link = new Link
         {
             OriginalUrl = request.Url,

src/SwiftLink.Application/UseCases/Links/Commands/GenerateShortCode/GenerateShortCodeValidator.cs

@@ -10,9 +10,9 @@ public GenerateShortCodeValidator()
             .NotNull().WithMessage(Constants.Link.UrlMustBeSent)
             .Must(BeAValidUrl).WithMessage(Constants.Link.InvalidUrlFormat);
 
-        RuleFor(x => x.Token)
-            .NotNull().WithMessage(Constants.Link.UrlMustBeSent)
-            .Must(BeAValidUrl).WithMessage(Constants.Link.InvalidUrlFormat);
+        //RuleFor(x => x.Token)
+        //    .NotNull().WithMessage(Constants.Link.UrlMustBeSent)
+        //    .Must(BeAValidUrl).WithMessage(Constants.Link.InvalidUrlFormat);
     }
 
     private bool BeAValidUrl(string url)

src/SwiftLink.Presentation/Middleware/BusinessValidationExceptionHandlingMiddleware.cs

@@ -0,0 +1,35 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using SwiftLink.Application.Common.Exceptions;
+using System;
+
+namespace SwiftLink.Presentation.Middleware;
+
+public sealed class BusinessValidationExceptionHandlingMiddleware(RequestDelegate next)
+{
+    private readonly RequestDelegate _next = next;
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await _next(context);
+        }
+        catch (BusinessValidationException exception)
+        {
+            var problemDetails = new ProblemDetails
+            {
+                Status = StatusCodes.Status400BadRequest,
+                Type = "ValidationFailure",
+                Title = "Validation error",
+                Detail = "One or more validation errors has occurred"
+            };
+
+            if (exception.Errors is not null)
+                problemDetails.Extensions["errors"] = exception.Errors;
+
+            context.Response.StatusCode = StatusCodes.Status400BadRequest;
+            await context.Response.WriteAsJsonAsync(problemDetails);
+        }
+    }
+}

src/SwiftLink.Presentation/Program.cs

@@ -6,6 +6,7 @@
 using SwiftLink.Infrastructure;
 using SwiftLink.Infrastructure.Persistence.Context;
 using SwiftLink.Presentation;
+using SwiftLink.Presentation.Middleware;
 using SwiftLink.Shared;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -41,6 +42,7 @@
 
 var app = builder.Build();
 {
+    app.UseMiddleware<BusinessValidationExceptionHandlingMiddleware>();
     app.UseExceptionHandler(error =>
     {
         error.Run(async context =>