the-biergarten-app/web/backend/Features/Features.Auth/Commands/RegisterUser/RegisterUserHandler.cs

using Domain.Exceptions;
using Features.Auth.Dtos;
using Features.Auth.Repository;
using Features.Auth.Services;
using Infrastructure.PasswordHashing;
using MediatR;
using Shared.Application.Emails;

namespace Features.Auth.Commands.RegisterUser;

/// <summary>
/// Handles <see cref="RegisterUserCommand"/>: validates uniqueness, hashes the password, persists the
/// account, issues access/refresh/confirmation tokens, and attempts to send the registration
/// confirmation email via Features.Emails.
/// </summary>
/// <param name="authRepo">Repository used to check for existing users and persist the new account.</param>
/// <param name="passwordInfrastructure">Infrastructure component used to hash the user's plain-text password.</param>
/// <param name="tokenService">Service used to generate access, refresh, and confirmation tokens.</param>
/// <param name="mediator">Used to send the cross-slice command that triggers the confirmation email.</param>
public class RegisterUserHandler(
    IAuthRepository authRepo,
    IPasswordInfrastructure passwordInfrastructure,
    ITokenService tokenService,
    IMediator mediator
) : IRequestHandler<RegisterUserCommand, RegistrationPayload>
{
    /// <exception cref="ConflictException">
    /// Thrown when an existing account already has the same username or email address.
    /// </exception>
    public async Task<RegistrationPayload> Handle(RegisterUserCommand request, CancellationToken cancellationToken)
    {
        await ValidateUserDoesNotExist(request.Username, request.Email);

        var hashed = passwordInfrastructure.Hash(request.Password);

        var createdUser = await authRepo.RegisterUserAsync(
            request.Username,
            request.FirstName,
            request.LastName,
            request.Email,
            request.DateOfBirth,
            hashed
        );

        var accessToken = tokenService.GenerateAccessToken(createdUser);
        var refreshToken = tokenService.GenerateRefreshToken(createdUser);
        var confirmationToken = tokenService.GenerateConfirmationToken(createdUser);

        if (string.IsNullOrEmpty(accessToken) || string.IsNullOrEmpty(refreshToken))
        {
            return new RegistrationPayload(createdUser.UserAccountId, createdUser.Username, string.Empty, string.Empty, false);
        }

        var emailSent = false;
        try
        {
            await mediator.Send(
                new SendRegistrationEmailCommand(createdUser.FirstName, createdUser.Email, confirmationToken),
                cancellationToken
            );
            emailSent = true;
        }
        catch (Exception ex)
        {
            await Console.Error.WriteLineAsync(ex.Message);
            Console.WriteLine("Could not send email.");
            // ignored
        }

        return new RegistrationPayload(createdUser.UserAccountId, createdUser.Username, refreshToken, accessToken, emailSent);
    }

    /// <exception cref="ConflictException">
    /// Thrown when an existing account already has the same username or email address.
    /// </exception>
    private async Task ValidateUserDoesNotExist(string username, string email)
    {
        var existingUsername = await authRepo.GetUserByUsernameAsync(username);
        var existingEmail = await authRepo.GetUserByEmailAsync(email);

        if (existingUsername != null || existingEmail != null)
        {
            throw new ConflictException("Username or email already exists");
        }
    }
}