shoc-backend/SeaHaven.DataServices/Implementation/TeamPermissionOverrideDataService.cs

using Data.SeaHavenIndustries;
using Data.SeaHavenIndustries.Enums;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Dto;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation;

public sealed class TeamPermissionOverrideDataService : ITeamPermissionOverrideDataService
{
    private readonly ApplicationDbContext _context;

    public TeamPermissionOverrideDataService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<TeamPermissionUserData?> GetUserAsync(
        string userId,
        CancellationToken cancellationToken)
    {
        var userExists = await _context.Users
            .AsNoTracking()
            .AnyAsync(user => user.Id == userId, cancellationToken);

        if (!userExists)
            return null;

        var roleName = await (
            from userRole in _context.UserRoles.AsNoTracking()
            join role in _context.Roles.AsNoTracking()
                on userRole.RoleId equals role.Id
            where userRole.UserId == userId
            select role.Name)
            .FirstOrDefaultAsync(cancellationToken);

        var overrides = await _context.UserPermissionOverrides
            .AsNoTracking()
            .Where(permission => permission.UserId == userId)
            .ToDictionaryAsync(
                permission => permission.PermissionKey,
                permission => permission.State,
                StringComparer.OrdinalIgnoreCase,
                cancellationToken);

        return new TeamPermissionUserData
        {
            UserId = userId,
            RoleName = roleName,
            Overrides = overrides
        };
    }

    public async Task SetOverrideAsync(
        string userId,
        string permissionKey,
        UserPermissionState state,
        CancellationToken cancellationToken)
    {
        var existing = await _context.UserPermissionOverrides
            .SingleOrDefaultAsync(
                permission => permission.UserId == userId
                    && permission.PermissionKey == permissionKey,
                cancellationToken);

        if (existing is null)
        {
            await _context.UserPermissionOverrides.AddAsync(
                new UserPermissionOverride
                {
                    UserId = userId,
                    PermissionKey = permissionKey,
                    State = state
                },
                cancellationToken);
        }
        else
        {
            existing.State = state;
        }

        await _context.SaveChangesAsync(cancellationToken);
    }
}