refactor namespaces and imports (#670)

* re-namespace

* optimize usings

* more usings

* more of the same

* more implicit/global usings

* cleanup all usings

* minor fixes

ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs

@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record BuildPlayout(int PlayoutId, bool Rebuild = false) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record BuildPlayout(int PlayoutId, bool Rebuild = false) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IBackgroundServiceRequest;

ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs

@@ -1,73 +1,69 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<BaseError, Unit>>
 {
-    public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IPlayoutBuilder _playoutBuilder;
+
+    public BuildPlayoutHandler(IDbContextFactory<TvContext> dbContextFactory, IPlayoutBuilder playoutBuilder)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IPlayoutBuilder _playoutBuilder;
-
-        public BuildPlayoutHandler(IDbContextFactory<TvContext> dbContextFactory, IPlayoutBuilder playoutBuilder)
-        {
-            _dbContextFactory = dbContextFactory;
-            _playoutBuilder = playoutBuilder;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, BuildPlayout request, Playout playout)
-        {
-            await _playoutBuilder.BuildPlayoutItems(playout, request.Rebuild);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, BuildPlayout request) =>
-            PlayoutMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
-            TvContext dbContext,
-            BuildPlayout buildPlayout) =>
-            dbContext.Playouts
-                .Include(p => p.Channel)
-                .Include(p => p.Items)
-                .Include(p => p.ProgramScheduleAnchors)
-                .ThenInclude(a => a.MediaItem)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.Collection)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.MediaItem)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.PreRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.MidRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.PostRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.TailFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.FallbackFiller)
-                .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
-                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+        _dbContextFactory = dbContextFactory;
+        _playoutBuilder = playoutBuilder;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => ApplyUpdateRequest(dbContext, request, playout));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, BuildPlayout request, Playout playout)
+    {
+        await _playoutBuilder.BuildPlayoutItems(playout, request.Rebuild);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, BuildPlayout request) =>
+        PlayoutMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+        TvContext dbContext,
+        BuildPlayout buildPlayout) =>
+        dbContext.Playouts
+            .Include(p => p.Channel)
+            .Include(p => p.Items)
+            .Include(p => p.ProgramScheduleAnchors)
+            .ThenInclude(a => a.MediaItem)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.Collection)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MediaItem)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PreRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MidRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PostRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.TailFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.FallbackFiller)
+            .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
+            .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+}

ErsatzTV.Application/Playouts/Commands/CreatePlayout.cs

@@ -1,12 +1,9 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record CreatePlayout(
-        int ChannelId,
-        int ProgramScheduleId,
-        ProgramSchedulePlayoutType ProgramSchedulePlayoutType) : IRequest<Either<BaseError, CreatePlayoutResponse>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record CreatePlayout(
+    int ChannelId,
+    int ProgramScheduleId,
+    ProgramSchedulePlayoutType ProgramSchedulePlayoutType) : IRequest<Either<BaseError, CreatePlayoutResponse>>;

ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs

@@ -1,95 +1,88 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 using Channel = ErsatzTV.Core.Domain.Channel;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class CreatePlayoutHandler : IRequestHandler<CreatePlayout, Either<BaseError, CreatePlayoutResponse>>
 {
-    public class CreatePlayoutHandler : IRequestHandler<CreatePlayout, Either<BaseError, CreatePlayoutResponse>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreatePlayoutHandler(
+        ChannelWriter<IBackgroundServiceRequest> channel,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreatePlayoutHandler(
-            ChannelWriter<IBackgroundServiceRequest> channel,
-            IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _channel = channel;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public async Task<Either<BaseError, CreatePlayoutResponse>> Handle(
-            CreatePlayout request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => PersistPlayout(dbContext, playout));
-        }
-
-        private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
-        {
-            await dbContext.Playouts.AddAsync(playout);
-            await dbContext.SaveChangesAsync();
-            await _channel.WriteAsync(new BuildPlayout(playout.Id));
-            return new CreatePlayoutResponse(playout.Id);
-        }
-
-        private async Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, CreatePlayout request) =>
-            (await ValidateChannel(dbContext, request), await ValidateProgramSchedule(dbContext, request),
-                ValidatePlayoutType(request))
-            .Apply(
-                (channel, programSchedule, playoutType) => new Playout
-                {
-                    ChannelId = channel.Id,
-                    ProgramScheduleId = programSchedule.Id,
-                    ProgramSchedulePlayoutType = playoutType
-                });
-
-        private static Task<Validation<BaseError, Channel>> ValidateChannel(
-            TvContext dbContext,
-            CreatePlayout createPlayout) =>
-            dbContext.Channels
-                .Include(c => c.Playouts)
-                .SelectOneAsync(c => c.Id, c => c.Id == createPlayout.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist"))
-                .BindT(ChannelMustNotHavePlayouts);
-
-        private static Validation<BaseError, Channel> ChannelMustNotHavePlayouts(Channel channel) =>
-            Optional(channel.Playouts.Count)
-                .Filter(count => count == 0)
-                .Map(_ => channel)
-                .ToValidation<BaseError>("Channel already has one playout");
-
-        private static Task<Validation<BaseError, ProgramSchedule>> ValidateProgramSchedule(
-            TvContext dbContext,
-            CreatePlayout createPlayout) =>
-            dbContext.ProgramSchedules
-                .Include(ps => ps.Items)
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == createPlayout.ProgramScheduleId)
-                .Map(o => o.ToValidation<BaseError>("Program schedule does not exist"))
-                .BindT(ProgramScheduleMustHaveItems);
-
-        private static Validation<BaseError, ProgramSchedule> ProgramScheduleMustHaveItems(
-            ProgramSchedule programSchedule) =>
-            Optional(programSchedule)
-                .Filter(ps => ps.Items.Any())
-                .ToValidation<BaseError>("Program schedule must have items");
-
-        private static Validation<BaseError, ProgramSchedulePlayoutType> ValidatePlayoutType(
-            CreatePlayout createPlayout) =>
-            Optional(createPlayout.ProgramSchedulePlayoutType)
-                .Filter(playoutType => playoutType != ProgramSchedulePlayoutType.None)
-                .ToValidation<BaseError>("[ProgramSchedulePlayoutType] must not be None");
+        _channel = channel;
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    public async Task<Either<BaseError, CreatePlayoutResponse>> Handle(
+        CreatePlayout request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => PersistPlayout(dbContext, playout));
+    }
+
+    private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
+    {
+        await dbContext.Playouts.AddAsync(playout);
+        await dbContext.SaveChangesAsync();
+        await _channel.WriteAsync(new BuildPlayout(playout.Id));
+        return new CreatePlayoutResponse(playout.Id);
+    }
+
+    private async Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, CreatePlayout request) =>
+        (await ValidateChannel(dbContext, request), await ValidateProgramSchedule(dbContext, request),
+            ValidatePlayoutType(request))
+        .Apply(
+            (channel, programSchedule, playoutType) => new Playout
+            {
+                ChannelId = channel.Id,
+                ProgramScheduleId = programSchedule.Id,
+                ProgramSchedulePlayoutType = playoutType
+            });
+
+    private static Task<Validation<BaseError, Channel>> ValidateChannel(
+        TvContext dbContext,
+        CreatePlayout createPlayout) =>
+        dbContext.Channels
+            .Include(c => c.Playouts)
+            .SelectOneAsync(c => c.Id, c => c.Id == createPlayout.ChannelId)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist"))
+            .BindT(ChannelMustNotHavePlayouts);
+
+    private static Validation<BaseError, Channel> ChannelMustNotHavePlayouts(Channel channel) =>
+        Optional(channel.Playouts.Count)
+            .Filter(count => count == 0)
+            .Map(_ => channel)
+            .ToValidation<BaseError>("Channel already has one playout");
+
+    private static Task<Validation<BaseError, ProgramSchedule>> ValidateProgramSchedule(
+        TvContext dbContext,
+        CreatePlayout createPlayout) =>
+        dbContext.ProgramSchedules
+            .Include(ps => ps.Items)
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == createPlayout.ProgramScheduleId)
+            .Map(o => o.ToValidation<BaseError>("Program schedule does not exist"))
+            .BindT(ProgramScheduleMustHaveItems);
+
+    private static Validation<BaseError, ProgramSchedule> ProgramScheduleMustHaveItems(
+        ProgramSchedule programSchedule) =>
+        Optional(programSchedule)
+            .Filter(ps => ps.Items.Any())
+            .ToValidation<BaseError>("Program schedule must have items");
+
+    private static Validation<BaseError, ProgramSchedulePlayoutType> ValidatePlayoutType(
+        CreatePlayout createPlayout) =>
+        Optional(createPlayout.ProgramSchedulePlayoutType)
+            .Filter(playoutType => playoutType != ProgramSchedulePlayoutType.None)
+            .ToValidation<BaseError>("[ProgramSchedulePlayoutType] must not be None");
+}

ErsatzTV.Application/Playouts/Commands/CreatePlayoutResponse.cs

@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record CreatePlayoutResponse(int PlayoutId);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record CreatePlayoutResponse(int PlayoutId);

ErsatzTV.Application/Playouts/Commands/DeletePlayout.cs

@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record DeletePlayout(int PlayoutId) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record DeletePlayout(int PlayoutId) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Playouts/Commands/DeletePlayoutHandler.cs

@@ -1,42 +1,35 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class DeletePlayoutHandler : IRequestHandler<DeletePlayout, Either<BaseError, Unit>>
 {
-    public class DeletePlayoutHandler : IRequestHandler<DeletePlayout, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeletePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeletePlayout request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public DeletePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        Option<Playout> maybePlayout = await dbContext.Playouts
+            .OrderBy(p => p.Id)
+            .FirstOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken);
 
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeletePlayout request,
-            CancellationToken cancellationToken)
+        foreach (Playout playout in maybePlayout)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Option<Playout> maybePlayout = await dbContext.Playouts
-                .OrderBy(p => p.Id)
-                .FirstOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken);
-
-            foreach (Playout playout in maybePlayout)
-            {
-                dbContext.Playouts.Remove(playout);
-                await dbContext.SaveChangesAsync(cancellationToken);
-            }
-
-            return maybePlayout
-                .Map(_ => Unit.Default)
-                .ToEither(BaseError.New($"Playout {request.PlayoutId} does not exist."));
+            dbContext.Playouts.Remove(playout);
+            await dbContext.SaveChangesAsync(cancellationToken);
         }
+
+        return maybePlayout
+            .Map(_ => Unit.Default)
+            .ToEither(BaseError.New($"Playout {request.PlayoutId} does not exist."));
     }
-}
+}

ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs

@@ -1,10 +1,6 @@
-using System;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record UpdatePlayout
-        (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record UpdatePlayout
+    (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;

ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs

@@ -1,65 +1,58 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
 {
-    public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
+        UpdatePlayout request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
-            UpdatePlayout request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
-        }
-
-        private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
-            TvContext dbContext,
-            UpdatePlayout request,
-            Playout playout)
-        {
-            playout.DailyRebuildTime = null;
-
-            foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
-            {
-                playout.DailyRebuildTime = dailyRebuildTime;
-            }
-
-            await dbContext.SaveChangesAsync();
-
-            return new PlayoutNameViewModel(
-                playout.Id,
-                playout.Channel.Name,
-                playout.Channel.Number,
-                playout.ProgramSchedule.Name,
-                Optional(playout.DailyRebuildTime));
-        }
-
-        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
-            PlayoutMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
-            TvContext dbContext,
-            UpdatePlayout updatePlayout) =>
-            dbContext.Playouts
-                .Include(p => p.Channel)
-                .Include(p => p.ProgramSchedule)
-                .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
-                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => ApplyUpdateRequest(dbContext, request, playout));
     }
-}
+
+    private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
+        TvContext dbContext,
+        UpdatePlayout request,
+        Playout playout)
+    {
+        playout.DailyRebuildTime = null;
+
+        foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
+        {
+            playout.DailyRebuildTime = dailyRebuildTime;
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return new PlayoutNameViewModel(
+            playout.Id,
+            playout.Channel.Name,
+            playout.Channel.Number,
+            playout.ProgramSchedule.Name,
+            Optional(playout.DailyRebuildTime));
+    }
+
+    private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
+        PlayoutMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+        TvContext dbContext,
+        UpdatePlayout updatePlayout) =>
+        dbContext.Playouts
+            .Include(p => p.Channel)
+            .Include(p => p.ProgramSchedule)
+            .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
+            .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+}

ErsatzTV.Application/Playouts/Mapper.cs

@@ -1,69 +1,66 @@
-using System;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Playouts
+namespace ErsatzTV.Application.Playouts;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
+        new(
+            GetDisplayTitle(playoutItem),
+            playoutItem.StartOffset,
+            GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));
+
+    private static string GetDisplayTitle(PlayoutItem playoutItem)
     {
-        internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
-            new(
-                GetDisplayTitle(playoutItem),
-                playoutItem.StartOffset,
-                GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));
-
-        private static string GetDisplayTitle(PlayoutItem playoutItem)
+        switch (playoutItem.MediaItem)
         {
-            switch (playoutItem.MediaItem)
-            {
-                case Episode e:
-                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
-                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
-                    var episodeNumbers = e.EpisodeMetadata.Map(em => em.EpisodeNumber).ToList();
-                    var episodeTitles = e.EpisodeMetadata.Map(em => em.Title).ToList();
-                    if (episodeNumbers.Count == 0 || episodeTitles.Count == 0)
-                    {
-                        return "[unknown episode]";
-                    }
+            case Episode e:
+                string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                    .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                var episodeNumbers = e.EpisodeMetadata.Map(em => em.EpisodeNumber).ToList();
+                var episodeTitles = e.EpisodeMetadata.Map(em => em.Title).ToList();
+                if (episodeNumbers.Count == 0 || episodeTitles.Count == 0)
+                {
+                    return "[unknown episode]";
+                }
 
-                    var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
-                    var titlesString = $"{string.Join('/', episodeTitles)}";
-                    if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
-                    {
-                        titlesString += $" ({playoutItem.ChapterTitle})";
-                    }
+                var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
+                var titlesString = $"{string.Join('/', episodeTitles)}";
+                if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
+                {
+                    titlesString += $" ({playoutItem.ChapterTitle})";
+                }
 
-                    return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
-                case Movie m:
-                    return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
-                case MusicVideo mv:
-                    string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
-                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
-                    return mv.MusicVideoMetadata.HeadOrNone()
-                        .Map(mvm => $"{artistName}{mvm.Title}")
-                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown music video]");
-                case OtherVideo ov:
-                    return ov.OtherVideoMetadata.HeadOrNone()
-                        .Map(ovm => ovm.Title ?? string.Empty)
-                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown video]");
-                case Song s:
-                    string songArtist = s.SongMetadata.HeadOrNone()
-                        .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
-                        .IfNone(string.Empty);
-                    return s.SongMetadata.HeadOrNone()
-                        .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
-                        .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown song]");
-                default:
-                    return string.Empty;
-            }
+                return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
+            case Movie m:
+                return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
+            case MusicVideo mv:
+                string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
+                    .Map(am => $"{am.Title} - ").IfNone(string.Empty);
+                return mv.MusicVideoMetadata.HeadOrNone()
+                    .Map(mvm => $"{artistName}{mvm.Title}")
+                    .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown music video]");
+            case OtherVideo ov:
+                return ov.OtherVideoMetadata.HeadOrNone()
+                    .Map(ovm => ovm.Title ?? string.Empty)
+                    .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown video]");
+            case Song s:
+                string songArtist = s.SongMetadata.HeadOrNone()
+                    .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
+                    .IfNone(string.Empty);
+                return s.SongMetadata.HeadOrNone()
+                    .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
+                    .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown song]");
+            default:
+                return string.Empty;
         }
-
-        private static string GetDisplayDuration(TimeSpan duration) =>
-            string.Format(
-                duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                duration);
     }
-}
+
+    private static string GetDisplayDuration(TimeSpan duration) =>
+        string.Format(
+            duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
+            duration);
+}

ErsatzTV.Application/Playouts/PagedPlayoutItemsViewModel.cs

@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PagedPlayoutItemsViewModel(int TotalCount, List<PlayoutItemViewModel> Page);
-}
+public record PagedPlayoutItemsViewModel(int TotalCount, List<PlayoutItemViewModel> Page);

ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs

@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutChannelViewModel(int Id, string Number, string Name);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutChannelViewModel(int Id, string Number, string Name);

ErsatzTV.Application/Playouts/PlayoutItemViewModel.cs

@@ -1,6 +1,3 @@
-using System;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutItemViewModel(string Title, DateTimeOffset Start, string Duration);
-}
+public record PlayoutItemViewModel(string Title, DateTimeOffset Start, string Duration);

ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs

@@ -1,12 +1,8 @@
-using System;
-using LanguageExt;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutNameViewModel(
-        int PlayoutId,
-        string ChannelName,
-        string ChannelNumber,
-        string ScheduleName,
-        Option<TimeSpan> DailyRebuildTime);
-}
+public record PlayoutNameViewModel(
+    int PlayoutId,
+    string ChannelName,
+    string ChannelNumber,
+    string ScheduleName,
+    Option<TimeSpan> DailyRebuildTime);

ErsatzTV.Application/Playouts/PlayoutProgramScheduleViewModel.cs

@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutProgramScheduleViewModel(int Id, string Name);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutProgramScheduleViewModel(int Id, string Name);

ErsatzTV.Application/Playouts/PlayoutViewModel.cs

@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutViewModel(
-        int Id,
-        PlayoutChannelViewModel Channel,
-        PlayoutProgramScheduleViewModel ProgramSchedule,
-        ProgramSchedulePlayoutType ProgramSchedulePlayoutType);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutViewModel(
+    int Id,
+    PlayoutChannelViewModel Channel,
+    PlayoutProgramScheduleViewModel ProgramSchedule,
+    ProgramSchedulePlayoutType ProgramSchedulePlayoutType);

ErsatzTV.Application/Playouts/Queries/GetAllPlayouts.cs

@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetAllPlayouts : IRequest<List<PlayoutNameViewModel>>;
-}
+public record GetAllPlayouts : IRequest<List<PlayoutNameViewModel>>;

ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs

@@ -1,35 +1,29 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Playouts.Queries
+namespace ErsatzTV.Application.Playouts;
+
+public class GetAllPlayoutsHandler : IRequestHandler<GetAllPlayouts, List<PlayoutNameViewModel>>
 {
-    public class GetAllPlayoutsHandler : IRequestHandler<GetAllPlayouts, List<PlayoutNameViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllPlayoutsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<PlayoutNameViewModel>> Handle(
+        GetAllPlayouts request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllPlayoutsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<PlayoutNameViewModel>> Handle(
-            GetAllPlayouts request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Playouts
-                .Filter(p => p.Channel != null && p.ProgramSchedule != null)
-                .Map(
-                    p => new PlayoutNameViewModel(
-                        p.Id,
-                        p.Channel.Name,
-                        p.Channel.Number,
-                        p.ProgramSchedule.Name,
-                        Optional(p.DailyRebuildTime)))
-                .ToListAsync(cancellationToken);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Playouts
+            .Filter(p => p.Channel != null && p.ProgramSchedule != null)
+            .Map(
+                p => new PlayoutNameViewModel(
+                    p.Id,
+                    p.Channel.Name,
+                    p.Channel.Number,
+                    p.ProgramSchedule.Name,
+                    Optional(p.DailyRebuildTime)))
+            .ToListAsync(cancellationToken);
     }
-}
+}

ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs

@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
-}
+public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;

ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs

@@ -1,76 +1,68 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Playouts.Mapper;
 
-namespace ErsatzTV.Application.Playouts.Queries
+namespace ErsatzTV.Application.Playouts;
+
+public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
 {
-    public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<PagedPlayoutItemsViewModel> Handle(
+        GetFuturePlayoutItemsById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        DateTime now = DateTimeOffset.Now.UtcDateTime;
 
-        public async Task<PagedPlayoutItemsViewModel> Handle(
-            GetFuturePlayoutItemsById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            DateTime now = DateTimeOffset.Now.UtcDateTime;
-
-            int totalCount = await dbContext.PlayoutItems
-                .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
+        int totalCount = await dbContext.PlayoutItems
+            .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
             
-            List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MovieMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).Artist)
-                .ThenInclude(mm => mm.ArtistMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).Season)
-                .ThenInclude(s => s.SeasonMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).Season.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).SongMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).MediaVersions)
-                .Filter(i => i.PlayoutId == request.PlayoutId)
-                .Filter(i => i.Finish >= now)
-                .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
-                .OrderBy(i => i.Start)
-                .Skip(request.PageNum * request.PageSize)
-                .Take(request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+        List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MovieMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).Artist)
+            .ThenInclude(mm => mm.ArtistMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).Season)
+            .ThenInclude(s => s.SeasonMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).Season.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).SongMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).MediaVersions)
+            .Filter(i => i.PlayoutId == request.PlayoutId)
+            .Filter(i => i.Finish >= now)
+            .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
+            .OrderBy(i => i.Start)
+            .Skip(request.PageNum * request.PageSize)
+            .Take(request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedPlayoutItemsViewModel(totalCount, page);
-        }
+        return new PagedPlayoutItemsViewModel(totalCount, page);
     }
-}
+}