Moonlight/Moonlight.Api/Services/UserDeletionService.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Hybrid;
using Moonlight.Api.Database;
using Moonlight.Api.Database.Entities;
using Moonlight.Api.Interfaces;

namespace Moonlight.Api.Services;

public class UserDeletionService
{
    private readonly DatabaseRepository<User> Repository;
    private readonly IEnumerable<IUserDeletionHook> Hooks;
    private readonly HybridCache HybridCache;

    public UserDeletionService(
        DatabaseRepository<User> repository,
        IEnumerable<IUserDeletionHook> hooks,
        HybridCache hybridCache
        )
    {
        Repository = repository;
        Hooks = hooks;
        HybridCache = hybridCache;
    }

    public async Task<UserDeletionValidationResult> ValidateAsync(int userId)
    {
        var user = await Repository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == userId);
        
        if(user == null)
            throw new AggregateException($"User with id {userId} not found");
        
        var errorMessages = new List<string>();

        foreach (var hook in Hooks)
        {
            if (await hook.ValidateAsync(user, errorMessages))
                continue;
            
            return new UserDeletionValidationResult(false, errorMessages);
        }
        
        return new UserDeletionValidationResult(true, []);
    }

    public async Task DeleteAsync(int userId)
    {
        var user = await Repository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == userId);
        
        if(user == null)
            throw new AggregateException($"User with id {userId} not found");
        
        foreach (var hook in Hooks)
            await hook.ExecuteAsync(user);
        
        await Repository.RemoveAsync(user);

        await HybridCache.RemoveAsync(string.Format(UserAuthService.CacheKeyPattern, user.Id));
    }
}

public record UserDeletionValidationResult(bool IsValid, IEnumerable<string> ErrorMessages);