ersatztv/ErsatzTV.Application/Scheduling/Commands/CreateDecoHandler.cs

using ErsatzTV.Core;
using ErsatzTV.Core.Domain.Scheduling;
using ErsatzTV.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;

namespace ErsatzTV.Application.Scheduling;

public class CreateDecoHandler(IDbContextFactory<TvContext> dbContextFactory)
    : IRequestHandler<CreateDeco, Either<BaseError, DecoViewModel>>
{
    public async Task<Either<BaseError, DecoViewModel>> Handle(
        CreateDeco request,
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
        Validation<BaseError, Deco> validation = await Validate(dbContext, request);
        return await validation.Apply(profile => PersistDeco(dbContext, profile));
    }

    private static async Task<DecoViewModel> PersistDeco(TvContext dbContext, Deco deco)
    {
        await dbContext.Decos.AddAsync(deco);
        await dbContext.SaveChangesAsync();
        await dbContext.Entry(deco).Reference(d => d.DecoGroup).LoadAsync();
        return Mapper.ProjectToViewModel(deco);
    }

    private static async Task<Validation<BaseError, Deco>> Validate(TvContext dbContext, CreateDeco request)
    {
        Validation<BaseError, Unit> decoGroupValidation = await ValidateDecoGroupExists(dbContext, request);
        Validation<BaseError, string> nameValidation = await ValidateDecoName(dbContext, request);

        return (decoGroupValidation, nameValidation).Apply((_, name) => new Deco
        {
            DecoGroupId = request.DecoGroupId,
            Name = name,
            BreakContent = [],
            DecoWatermarks = [],
            DecoGraphicsElements = []
        });
    }

    private static async Task<Validation<BaseError, Unit>> ValidateDecoGroupExists(
        TvContext dbContext,
        CreateDeco request)
    {
        bool decoGroupExists = await dbContext.DecoGroups.AnyAsync(dg => dg.Id == request.DecoGroupId);

        return decoGroupExists
            ? Success<BaseError, Unit>(Unit.Default)
            : BaseError.New("Deco group does not exist");
    }

    private static async Task<Validation<BaseError, string>> ValidateDecoName(
        TvContext dbContext,
        CreateDeco request)
    {
        if (string.IsNullOrWhiteSpace(request.Name) || request.Name.Length > 50)
        {
            return BaseError.New($"Deco name \"{request.Name}\" is invalid");
        }

        bool duplicateName = await dbContext.Decos
            .AnyAsync(r => r.DecoGroupId == request.DecoGroupId && r.Name == request.Name);

        return duplicateName
            ? BaseError.New($"A deco named \"{request.Name}\" already exists in that deco group")
            : Success<BaseError, string>(request.Name);
    }
}