Merge pull request #20 from InvisibleSafe/authservice-add-application-and-infrastructure-layers

AuthService: Add Application and Infrastructure layers

Author: sentemon

backend/src/AuthService/AuthService.Api/Middleware/ExceptionHandlingMiddleware.cs

@@ -0,0 +1,34 @@
+namespace AuthService.Api.Middleware;
+
+public class ExceptionHandlingMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    public ExceptionHandlingMiddleware(RequestDelegate next)
+    {
+        _next = next;
+    }
+
+    public async Task InvokeAsync(HttpContext httpContext)
+    {
+        try
+        {
+            await _next(httpContext);
+        }
+        catch (HttpRequestException ex)
+        {
+            httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
+            await httpContext.Response.WriteAsync($"HTTP Error: {ex.Message}");
+        }
+        catch (TaskCanceledException ex)
+        {
+            httpContext.Response.StatusCode = StatusCodes.Status408RequestTimeout;
+            await httpContext.Response.WriteAsync($"Request Timeout: {ex.Message}");
+        }
+        catch (Exception ex)
+        {
+            httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
+            await httpContext.Response.WriteAsync($"Unexpected error: {ex.Message}");
+        }
+    }
+}

backend/src/AuthService/AuthService.Api/Program.cs

@@ -2,19 +2,35 @@
 using AuthService.Domain.Constants;
 using AuthService.Infrastructure;
 using AuthService.Persistence;
+using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.EntityFrameworkCore;
 
 var builder = WebApplication.CreateBuilder(args);
 
 var hostingUrl = builder.Configuration[AppSettingsConstants.WebHostUrl];
-
 var connectionString = builder.Configuration[AppSettingsConstants.DatabaseConnectionString];
+var allowedOrigins = builder.Configuration.GetSection(AppSettingsConstants.AllowedOrigins).Get<string[]>();
 
 builder.WebHost.UseUrls(hostingUrl ?? throw new ArgumentNullException(nameof(hostingUrl), "Hosting URL is not configured."));
 
+// ToDo: move to extension method
+builder.Services
+    .AddCors(options =>
+    {
+        options.AddPolicy("CorsPolicy", policyBuilder =>
+        {
+            policyBuilder
+                .WithOrigins(allowedOrigins ?? throw new ArgumentNullException(nameof(allowedOrigins),
+                    "Allowed Origin URLs are not configured."))
+                .AllowCredentials()
+                .AllowAnyHeader()
+                .AllowAnyMethod();
+        });
+    });
+
 builder.Services
     .AddPersistenceServices(connectionString)
-    .AddInfrastructureServices()
+    .AddInfrastructureServices(builder.Configuration)
     .AddApplicationServices();
 
 var app = builder.Build();
@@ -25,6 +41,13 @@
     dbContext.Database.Migrate();
 }
 
-app.UseHttpsRedirection();
+app.UseMiddleware<ExceptionHandlerMiddleware>();
+
+// app.UseHttpsRedirection();
+
+app.UseCors("CorsPolicy");
+
+app.UseAuthentication();
+app.UseAuthorization();
 
 app.Run();

backend/src/AuthService/AuthService.Api/appsettings.json

@@ -6,6 +6,15 @@
     }
   },
   "AllowedHosts": "*",
+  "AllowedOrigins": [ "http://localhost:4000", "http://localhost:4200", "http://localhost:8080" ],
   "DatabaseConnectionString": "Host=localhost;Port=5432;Username=postgres;Password=mysecretpasswordfordevelopment;Database=AuthDb",
-  "WebHostUrl": "http://0.0.0.0:8082"
+  "WebHostUrl": "http://0.0.0.0:8082",
+  "Keycloak": {
+    "Url": "http://localhost:8080",
+    "Realm": "fitness-app-realm",
+    "ClientId": "fitness-app-client",
+    "ClientSecret": "4mTuelQIWNfLw3HGfE3xAD3Bmyb5OHWN",
+    "AdminUsername": "admin",
+    "AdminPassword": "admin"
+  }
 }

backend/src/AuthService/AuthService.Application/AuthService.Application.csproj

@@ -7,6 +7,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\..\Shared\Shared.Application\Shared.Application.csproj" />
       <ProjectReference Include="..\AuthService.Domain\AuthService.Domain.csproj" />
       <ProjectReference Include="..\AuthService.Infrastructure\AuthService.Infrastructure.csproj" />
       <ProjectReference Include="..\AuthService.Persistence\AuthService.Persistence.csproj" />

backend/src/AuthService/AuthService.Application/Commands/Login/LoginCommand.cs

@@ -0,0 +1,6 @@
+using AuthService.Application.DTOs;
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.Login;
+
+public record LoginCommand(LoginDto LoginDto) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/Login/LoginCommandHandler.cs

@@ -0,0 +1,22 @@
+using AuthService.Infrastructure.Interfaces;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.Login;
+
+public class LoginCommandHandler : ICommandHandler<LoginCommand, string>
+{
+    private readonly IAuthService _authService;
+
+    public LoginCommandHandler(IAuthService authService)
+    {
+        _authService = authService;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(LoginCommand command)
+    {
+        var token = await _authService.LoginAsync(command.LoginDto.Username, command.LoginDto.Password);
+
+        return Result<string>.Success(token.AccessToken);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/Logout/LogoutCommand.cs

@@ -0,0 +1,5 @@
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.Logout;
+
+public record LogoutCommand(string RefreshToken) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/Logout/LogoutCommandHandler.cs

@@ -0,0 +1,28 @@
+using AuthService.Domain.Constants;
+using AuthService.Infrastructure.Interfaces;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.Logout;
+
+public class LogoutCommandHandler : ICommandHandler<LogoutCommand, string>
+{
+    private readonly IAuthService _authService;
+
+    public LogoutCommandHandler(IAuthService authService)
+    {
+        _authService = authService;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(LogoutCommand command)
+    {
+        var result = await _authService.LogoutAsync(command.RefreshToken);
+
+        if (!result)
+        {
+            return Result<string>.Failure(new Error(ResponseMessages.ErrorDuringLogout));
+        }
+        
+        return Result<string>.Success(ResponseMessages.LoggedOutSuccessfully);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/Register/RegisterCommand.cs

@@ -0,0 +1,6 @@
+using AuthService.Application.DTOs;
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.Register;
+
+public record RegisterCommand(RegisterDto RegisterDto) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/Register/RegisterCommandHandler.cs

@@ -0,0 +1,35 @@
+using AuthService.Infrastructure.Interfaces;
+using AuthService.Persistence;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.Register;
+
+public class RegisterCommandHandler : ICommandHandler<RegisterCommand, string>
+{
+    private readonly AuthDbContext _context;
+    private readonly IAuthService _authService;
+
+    public RegisterCommandHandler(AuthDbContext context, IAuthService authService)
+    {
+        _context = context;
+        _authService = authService;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(RegisterCommand command)
+    {
+        var user = await _authService.RegisterAsync(
+            command.RegisterDto.FirstName,
+            command.RegisterDto.LastName,
+            command.RegisterDto.Username, 
+            command.RegisterDto.Email,
+            command.RegisterDto.Password);
+
+        _context.Users.Add(user);
+        await _context.SaveChangesAsync();
+
+        var token = await _authService.LoginAsync(command.RegisterDto.Username, command.RegisterDto.Password);
+        
+        return Result<string>.Success(token.AccessToken);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/ResetPassword/ResetPasswordCommand.cs

@@ -0,0 +1,5 @@
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.ResetPassword;
+
+public record ResetPasswordCommand(string UserId, string NewPassword) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/ResetPassword/ResetPasswordCommandHandler.cs

@@ -0,0 +1,28 @@
+using AuthService.Domain.Constants;
+using AuthService.Infrastructure.Interfaces;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.ResetPassword;
+
+public class ResetPasswordCommandHandler : ICommandHandler<ResetPasswordCommand, string>
+{
+    private readonly IUserService _userService;
+
+    public ResetPasswordCommandHandler(IUserService userService)
+    {
+        _userService = userService;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(ResetPasswordCommand command)
+    {
+        var result = await _userService.ResetPasswordAsync(command.UserId, command.NewPassword);
+
+        if (!result)
+        {
+            return Result<string>.Failure(new Error(ResponseMessages.ErrorDuringResetPassword));
+        }
+        
+        return Result<string>.Success(ResponseMessages.PasswordUpdatedSuccessfully);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/SendVerifyEmail/SendVerifyEmailCommand.cs

@@ -0,0 +1,5 @@
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.SendVerifyEmail;
+
+public record SendVerifyEmailCommand(string UserId) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/SendVerifyEmail/SendVerifyEmailCommandHandler.cs

@@ -0,0 +1,40 @@
+using AuthService.Application.Commands.VerifyEmail;
+using AuthService.Domain.Constants;
+using AuthService.Infrastructure.Interfaces;
+using AuthService.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.SendVerifyEmail;
+
+public class SendVerifyEmailCommandHandler : ICommandHandler<VerifyEmailCommand, string>
+{
+    private readonly AuthDbContext _context;
+    private readonly IAuthService _authService;
+
+    public SendVerifyEmailCommandHandler(AuthDbContext context, IAuthService authService)
+    {
+        _context = context;
+        _authService = authService;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(VerifyEmailCommand command)
+    {
+        var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == command.UserId);
+
+        if (user == null)
+        {
+            return Result<string>.Failure(new Error(ResponseMessages.UserNotFound));
+        }
+        
+        var result = await _authService.SendVerifyEmailAsync(command.UserId);
+
+        if (!result)
+        {
+            return Result<string>.Failure(new Error(ResponseMessages.ErrorDuringSendVerifyEmail));
+        }
+        
+        return Result<string>.Success(ResponseMessages.EmailVerificationSentSuccessfully);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/UpdateUser/UpdateUserCommand.cs

@@ -0,0 +1,6 @@
+using AuthService.Application.DTOs;
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.UpdateUser;
+
+public record UpdateUserCommand(UpdateUserDto UpdateUserDto, string Id) : ICommand;

backend/src/AuthService/AuthService.Application/Commands/UpdateUser/UpdateUserCommandHandler.cs

@@ -0,0 +1,49 @@
+using AuthService.Domain.Constants;
+using AuthService.Infrastructure.Interfaces;
+using AuthService.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Shared.Application.Abstractions;
+using Shared.Application.Common;
+
+namespace AuthService.Application.Commands.UpdateUser;
+
+public class UpdateUserCommandHandler : ICommandHandler<UpdateUserCommand, string>
+{
+    private readonly IUserService _userService;
+    private readonly AuthDbContext _context;
+
+    public UpdateUserCommandHandler(IUserService userService, AuthDbContext context)
+    {
+        _userService = userService;
+        _context = context;
+    }
+
+    public async Task<IResult<string, Error>> HandleAsync(UpdateUserCommand command)
+    {
+        var updatedUser = await _userService.UpdateAsync(
+            command.Id,
+            command.UpdateUserDto.FirstName,
+            command.UpdateUserDto.LastName,
+            command.UpdateUserDto.Username,
+            command.UpdateUserDto.Email
+        );
+
+        var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == updatedUser.Id);
+
+        if (user == null)
+        {
+            return Result<string>.Failure(new Error(ResponseMessages.UserNotFound));
+        }
+        
+        user.Update(
+            command.UpdateUserDto.FirstName,
+            command.UpdateUserDto.LastName,
+            command.UpdateUserDto.Username,
+            command.UpdateUserDto.Email
+        );
+        
+        await _context.SaveChangesAsync();
+        
+        return Result<string>.Success(ResponseMessages.UserUpdatedSuccessfully);
+    }
+}

backend/src/AuthService/AuthService.Application/Commands/VerifyEmail/VerifyEmailCommand.cs

@@ -0,0 +1,5 @@
+using Shared.Application.Abstractions;
+
+namespace AuthService.Application.Commands.VerifyEmail;
+
+public record VerifyEmailCommand(string UserId) : ICommand;