feat: configuration fluent validation

Living.Application/UseCases/Users/Login/LoginUserCommand.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Http;
+using FluentValidation;
+using Microsoft.AspNetCore.Http;
 
 namespace Living.Application.UseCases.Users.Login;
 public class LoginUserCommand : IRequest<IResult>
@@ -8,3 +9,15 @@ public class LoginUserCommand : IRequest<IResult>
 
     public bool UseCookies { get; set; } = true;
 }
+
+public class LoginCommandValidator : AbstractValidator<LoginUserCommand>
+{
+    public LoginCommandValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty().WithErrorCode("IS_REQUIRED")
+            .EmailAddress().WithErrorCode("IS_EMAIL");
+        RuleFor(x => x.Password)
+            .NotEmpty().WithErrorCode("IS_REQUIRED");
+    }
+}

Living.Application/UseCases/Users/Login/LoginUserHandler.cs

@@ -13,11 +13,11 @@ public async Task<IResult> Handle(LoginUserCommand request, CancellationToken ca
         var user = await userManager.FindByEmailAsync(request.Email);
 
         if (user is null)
-            return Results.NotFound(new BaseResponse(UserErrors.USER_NOT_FOUND));
+            return Results.NotFound(new BaseResponse(UserErrors.NOT_FOUND));
 
         var passwordIsValid = await userManager.CheckPasswordAsync(user, request.Password);
         if (!passwordIsValid)
-            return Results.BadRequest(new BaseResponse(UserErrors.USER_PASSWORD_INVALID));
+            return Results.BadRequest(new BaseResponse(UserErrors.PASSWORD_INVALID));
 
         var authenticationScheme = request.UseCookies ? IdentityConstants.ApplicationScheme : BearerTokenDefaults.AuthenticationScheme;
 

Living.Domain/Entities/Users/Constants/UserErrors.cs

@@ -3,8 +3,8 @@
 namespace Living.Domain.Entities.Users.Constants;
 public class UserErrors
 {
-    public static Notification USER_NOT_FOUND => new("USER", nameof(USER_NOT_FOUND));
-    public static Notification USER_PASSWORD_INVALID => new("USER", nameof(USER_NOT_FOUND));
-    public static Notification USER_EMAIL_ALREADY_IN_USE => new("USER", nameof(USER_NOT_FOUND));
-    public static Notification USER_USERNAME_ALREADY_IN_USE => new("USER", nameof(USER_NOT_FOUND));
+    public static Notification NOT_FOUND => new("USER", nameof(NOT_FOUND));
+    public static Notification PASSWORD_INVALID => new("USER", nameof(NOT_FOUND));
+    public static Notification EMAIL_ALREADY_IN_USE => new("USER", nameof(NOT_FOUND));
+    public static Notification USERNAME_ALREADY_IN_USE => new("USER", nameof(NOT_FOUND));
 }

Living.WebAPI/Controllers/AuthController.cs

@@ -8,13 +8,13 @@ namespace Living.WebAPI.Controllers;
 public class AuthController(IMediator mediator) : ControllerBase
 {
     [HttpPost("register")]
-    public async Task<IResult> Register(RegisterUserCommand command)
+    public async Task<IResult> Register([FromBody] RegisterUserCommand command)
     {
         return await mediator.Send(command);
     }
 
     [HttpPost("login")]
-    public async Task<IResult> Login(LoginUserCommand command)
+    public async Task<IResult> Login([FromBody] LoginUserCommand command)
     {
         return await mediator.Send(command);
     }

Living.WebAPI/ExceptionsHandler/FluentValidationExceptionHandler.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+using Living.Domain.Base;
+using Microsoft.AspNetCore.Diagnostics;
+
+namespace Living.WebAPI.ExceptionsHandler;
+
+public class FluentValidationExceptionHandler : IExceptionHandler
+{
+    public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
+    {
+        if (exception is ValidationException validation)
+        {
+            var notifications = validation.Errors.Select(e => new Notification(e.PropertyName.ToUpper(), e.ErrorCode));
+
+            httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+            await httpContext.Response.WriteAsJsonAsync(new BaseResponse(notifications.DistinctBy(p => p.Code)), cancellationToken);
+
+            return true;
+        }
+
+        return false;
+    }
+}

Living.WebAPI/Program.cs

@@ -8,6 +8,9 @@
 using Microsoft.AspNetCore.Identity;
 using Living.Infraestructure.Context;
 using Living.Infraestructure.Context.Interceptors;
+using Living.Application.UseCases.Users.Login;
+using MediatR.Extensions.FluentValidation.AspNetCore;
+using Living.WebAPI.ExceptionsHandler;
 
 namespace Living.WebAPI;
 public class Program
@@ -19,7 +22,8 @@ public static void Main(string[] args)
         builder.Services.AddDbContext<DatabaseContext>(options =>
         {
             options.AddInterceptors(new TimestampsInterceptor());
-            options.UseNpgsql(builder.Configuration["PostgresConnection"]);
+            //options.UseNpgsql(builder.Configuration["PostgresConnection"]);
+            options.UseInMemoryDatabase("Living");
         });
 
         builder.Services.AddControllers();
@@ -39,7 +43,12 @@ public static void Main(string[] args)
 
         builder.Services.AddAutoMapper(typeof(BaseProfile));
 
-        builder.Services.AddValidatorsFromAssemblyContaining<CreatePostValidator>();
+        builder.Services.AddValidatorsFromAssemblyContaining<LoginUserCommand>();
+
+        builder.Services.AddFluentValidation([typeof(LoginUserCommand).Assembly]);
+
+        builder.Services.AddExceptionHandler<FluentValidationExceptionHandler>();
+        builder.Services.AddProblemDetails();
 
         builder.Services.AddMediatR(configuration =>
         {
@@ -49,6 +58,11 @@ public static void Main(string[] args)
         builder.Services.AddAuthentication().AddBearerToken();
         builder.Services.AddAuthorization();
 
+        builder.Services.AddCors(options => options.AddDefaultPolicy(
+        builder => builder.AllowAnyOrigin()
+                .AllowAnyHeader()
+                .AllowAnyMethod()));
+
         var app = builder.Build();
 
         if (app.Environment.IsDevelopment())
@@ -59,6 +73,10 @@ public static void Main(string[] args)
 
         app.UseAuthentication();
 
+        app.UseCors();
+
+        app.UseExceptionHandler();
+
         app.UseHttpsRedirection();
 
         app.UseAuthorization();