navigate to schedule items after creating new schedule (#118)

* add explicit warning for zero/invalid duration media items

* set dateadded on plex media versions

* add media stream table

* save local media streams to db

* save plex media streams to db

* add preferred language settings (no validation)

* use preferred language if possible

* code cleanup

* proper language code validation

* force scan of all libraries to pull in media streams

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: jasongdove
+custom: "https://www.paypal.me/jasongdove"

.github/workflows/ci.yml

@@ -4,9 +4,8 @@ on:
   push:
     branches:
       - main
-      - develop
 jobs:
-  build:
+  build_and_test:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -32,3 +31,79 @@ jobs:
 
       - name: Test
         run: dotnet test --no-restore --verbosity normal
+  build_and_push:
+    name: Build & Publish to Docker Hub
+    needs: build_and_test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no ci]')
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Extract Git Tag
+        shell: bash
+        run: |
+          tag=$(git describe --tags --abbrev=0)
+          tag2="${tag:1}"
+          short=$(git rev-parse --short HEAD)
+          final="${tag2/prealpha/$short}"
+          echo "GIT_TAG=${final}" >> $GITHUB_ENV
+
+      - name: Set up Docker Buildx Base
+        uses: docker/setup-buildx-action@v1
+        id: builder-base
+
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Build and push base
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-base.outputs.name }}
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:develop
+            jasongdove/ersatztv:${{ github.sha }}
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
+          context: .
+          file: ./docker/nvidia/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
+          tags: |
+            jasongdove/ersatztv:develop-nvidia
+            jasongdove/ersatztv:${{ github.sha }}-nvidia
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
+          context: .
+          file: ./docker/vaapi/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
+          tags: |
+            jasongdove/ersatztv:develop-vaapi
+            jasongdove/ersatztv:${{ github.sha }}-vaapi

.github/workflows/release.yml

@@ -39,24 +39,24 @@ jobs:
           # Define some variables for things we need
           tag=$(git describe --tags --abbrev=0)
           release_name="ErsatzTV-$tag-${{ matrix.target }}"
-          release_name_cli="ErsatzTV.CommandLine-$tag-${{ matrix.target }}"
+          #release_name_cli="ErsatzTV.CommandLine-$tag-${{ matrix.target }}"
 
           # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name"
-          dotnet publish ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name_cli"
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}"
+          #dotnet publish ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name_cli" /property:InformationalVersion="${tag:1}-${{ matrix.target }}"
 
           # Pack files
           if [ "${{ matrix.target }}" == "win-x64" ]; then
             7z a -tzip "${release_name}.zip" "./${release_name}/*"
-            7z a -tzip "${release_name_cli}.zip" "./${release_name_cli}/*"
+            #7z a -tzip "${release_name_cli}.zip" "./${release_name_cli}/*"
           else
             tar czvf "${release_name}.tar.gz" "$release_name"
-            tar czvf "${release_name_cli}.tar.gz" "$release_name_cli"
+            #tar czvf "${release_name_cli}.tar.gz" "$release_name_cli"
           fi
 
           # Delete output directory
           rm -r "$release_name"
-          rm -r "$release_name_cli"
+          #rm -r "$release_name_cli"
 
       - name: Publish
         uses: softprops/action-gh-release@v1
@@ -67,3 +67,75 @@ jobs:
             ErsatzTV*.tar.gz
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  build_and_push:
+    name: Build & Publish to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Extract Git Tag
+        shell: bash
+        run: |
+          tag=$(git describe --tags --abbrev=0)
+          echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag/-prealpha/}" >> $GITHUB_ENV
+
+      - name: Set up Docker Buildx Base
+        uses: docker/setup-buildx-action@v1
+        id: builder-base
+
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Build and push base
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-base.outputs.name }}
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:latest
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
+          context: .
+          file: ./docker/nvidia/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
+          tags: |
+            jasongdove/ersatztv:latest-nvidia
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-nvidia
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
+          context: .
+          file: ./docker/vaapi/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
+          tags: |
+            jasongdove/ersatztv:latest-vaapi
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-vaapi

Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+    <PropertyGroup>
+        <InformationalVersion>develop</InformationalVersion>
+    </PropertyGroup>
+</Project>

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -4,9 +4,10 @@ namespace ErsatzTV.Application.Channels
 {
     public record ChannelViewModel(
         int Id,
-        int Number,
+        string Number,
         string Name,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -8,8 +8,9 @@ namespace ErsatzTV.Application.Channels.Commands
     public record CreateChannel
     (
         string Name,
-        int Number,
+        string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,4 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -7,6 +11,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Commands
 {
@@ -34,21 +39,61 @@ namespace ErsatzTV.Application.Channels.Commands
             _channelRepository.Add(c).Map(ProjectToViewModel);
 
         private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
-            (ValidateName(request), ValidateNumber(request), await FFmpegProfileMustExist(request))
+            (ValidateName(request), await ValidateNumber(request), await FFmpegProfileMustExist(request),
+                ValidatePreferredLanguage(request))
             .Apply(
-                (name, number, ffmpegProfileId) => new Channel(Guid.NewGuid())
+                (name, number, ffmpegProfileId, preferredLanguageCode) =>
                 {
-                    Name = name, Number = number, FFmpegProfileId = ffmpegProfileId,
-                    StreamingMode = request.StreamingMode
+                    var artwork = new List<Artwork>();
+                    if (!string.IsNullOrWhiteSpace(request.Logo))
+                    {
+                        artwork.Add(
+                            new Artwork
+                            {
+                                Path = request.Logo,
+                                ArtworkKind = ArtworkKind.Logo,
+                                DateAdded = DateTime.UtcNow,
+                                DateUpdated = DateTime.UtcNow
+                            });
+                    }
+
+                    return new Channel(Guid.NewGuid())
+                    {
+                        Name = name,
+                        Number = number,
+                        FFmpegProfileId = ffmpegProfileId,
+                        StreamingMode = request.StreamingMode,
+                        Artwork = artwork,
+                        PreferredLanguageCode = preferredLanguageCode
+                    };
                 });
 
         private Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
             createChannel.NotEmpty(c => c.Name)
                 .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
-        // TODO: validate number does not exist?
-        private Validation<BaseError, int> ValidateNumber(CreateChannel createChannel) =>
-            createChannel.AtLeast(1)(c => c.Number);
+        private Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
+            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
+
+        private async Task<Validation<BaseError, string>> ValidateNumber(CreateChannel createChannel)
+        {
+            Option<Channel> maybeExistingChannel = await _channelRepository.GetByNumber(createChannel.Number);
+            return maybeExistingChannel.Match<Validation<BaseError, string>>(
+                _ => BaseError.New("Channel number must be unique"),
+                () =>
+                {
+                    if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
+                    {
+                        return createChannel.Number;
+                    }
+
+                    return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+                });
+        }
 
         private async Task<Validation<BaseError, int>> FFmpegProfileMustExist(CreateChannel createChannel) =>
             (await _ffmpegProfileRepository.Get(createChannel.FFmpegProfileId))

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -9,8 +9,9 @@ namespace ErsatzTV.Application.Channels.Commands
     (
         int ChannelId,
         string Name,
-        int Number,
+        string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,4 +1,9 @@
-using System.Threading;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -6,6 +11,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Commands
 {
@@ -27,15 +33,43 @@ namespace ErsatzTV.Application.Channels.Commands
             c.Name = update.Name;
             c.Number = update.Number;
             c.FFmpegProfileId = update.FFmpegProfileId;
-            c.Logo = update.Logo;
+            c.PreferredLanguageCode = update.PreferredLanguageCode;
+
+            if (!string.IsNullOrWhiteSpace(update.Logo))
+            {
+                c.Artwork ??= new List<Artwork>();
+
+                Option<Artwork> maybeLogo =
+                    Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
+
+                maybeLogo.Match(
+                    artwork =>
+                    {
+                        artwork.Path = update.Logo;
+                        artwork.DateUpdated = DateTime.UtcNow;
+                    },
+                    () =>
+                    {
+                        var artwork = new Artwork
+                        {
+                            Path = update.Logo,
+                            DateAdded = DateTime.UtcNow,
+                            DateUpdated = DateTime.UtcNow,
+                            ArtworkKind = ArtworkKind.Logo
+                        };
+                        c.Artwork.Add(artwork);
+                    });
+            }
+
             c.StreamingMode = update.StreamingMode;
             await _channelRepository.Update(c);
             return ProjectToViewModel(c);
         }
 
         private async Task<Validation<BaseError, Channel>> Validate(UpdateChannel request) =>
-            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request))
-            .Apply((channelToUpdate, _, _) => channelToUpdate);
+            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request),
+                ValidatePreferredLanguage(request))
+            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
 
         private Task<Validation<BaseError, Channel>> ChannelMustExist(UpdateChannel updateChannel) =>
             _channelRepository.Get(updateChannel.ChannelId)
@@ -45,16 +79,28 @@ namespace ErsatzTV.Application.Channels.Commands
             updateChannel.NotEmpty(c => c.Name)
                 .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
 
-        private async Task<Validation<BaseError, int>> ValidateNumber(UpdateChannel updateChannel)
+        private async Task<Validation<BaseError, string>> ValidateNumber(UpdateChannel updateChannel)
         {
             Option<Channel> match = await _channelRepository.GetByNumber(updateChannel.Number);
             int matchId = match.Map(c => c.Id).IfNone(updateChannel.ChannelId);
             if (matchId == updateChannel.ChannelId)
             {
-                return updateChannel.AtLeast(1)(c => c.Number);
+                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+                {
+                    return updateChannel.Number;
+                }
+
+                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
             }
 
             return BaseError.New("Channel number must be unique");
         }
+
+        private Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
     }
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,10 +1,23 @@
-using ErsatzTV.Core.Domain;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels
 {
     internal static class Mapper
     {
         internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-            new(channel.Id, channel.Number, channel.Name, channel.FFmpegProfileId, channel.Logo, channel.StreamingMode);
+            new(
+                channel.Id,
+                channel.Number,
+                channel.Name,
+                channel.FFmpegProfileId,
+                GetLogo(channel),
+                channel.PreferredLanguageCode,
+                channel.StreamingMode);
+
+        private static string GetLogo(Channel channel) =>
+            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+                .Match(a => a.Path, string.Empty);
     }
 }

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -3,9 +3,9 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Queries
 {
@@ -15,7 +15,7 @@ namespace ErsatzTV.Application.Channels.Queries
 
         public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll().Map(channels => channels.Map(ProjectToViewModel).ToList());
+        public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
+            Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
     }
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -1,4 +1,5 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
 
@@ -8,6 +9,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         string Name,
         int ThreadCount,
         bool Transcode,
+        HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
         bool NormalizeResolution,
         string VideoCodec,

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -41,6 +41,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     Name = name,
                     ThreadCount = threadCount,
                     Transcode = request.Transcode,
+                    HardwareAcceleration = request.HardwareAcceleration,
                     ResolutionId = resolutionId,
                     NormalizeResolution = request.NormalizeResolution,
                     VideoCodec = request.VideoCodec,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -1,4 +1,5 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
 
@@ -9,6 +10,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         string Name,
         int ThreadCount,
         bool Transcode,
+        HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
         bool NormalizeResolution,
         string VideoCodec,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -35,6 +35,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.Name = update.Name;
             p.ThreadCount = update.ThreadCount;
             p.Transcode = update.Transcode;
+            p.HardwareAcceleration = update.HardwareAcceleration;
             p.ResolutionId = update.ResolutionId;
             p.NormalizeResolution = update.NormalizeResolution;
             p.VideoCodec = update.VideoCodec;

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs

@@ -1,6 +1,7 @@
-using MediatR;
+using ErsatzTV.Core;
+using LanguageExt;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
 {
-    public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : IRequest;
+    public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,28 +1,77 @@
-using System.Threading;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using MediatR;
-using Unit = MediatR.Unit;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
 {
-    public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings>
+    public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
     {
         private readonly IConfigElementRepository _configElementRepository;
+        private readonly ILocalFileSystem _localFileSystem;
 
-        public UpdateFFmpegSettingsHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<Unit> Handle(UpdateFFmpegSettings request, CancellationToken cancellationToken)
+        public UpdateFFmpegSettingsHandler(
+            IConfigElementRepository configElementRepository,
+            ILocalFileSystem localFileSystem)
         {
-            Option<ConfigElement> ffmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
-            Option<ConfigElement> ffprobePath = await _configElementRepository.Get(ConfigElementKey.FFprobePath);
-            Option<ConfigElement> defaultFFmpegProfileId =
-                await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId);
+            _configElementRepository = configElementRepository;
+            _localFileSystem = localFileSystem;
+        }
 
-            ffmpegPath.Match(
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateFFmpegSettings request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyUpdate(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
+            (await FFmpegMustExist(request), await FFprobeMustExist(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
+            ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
+
+        private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
+            ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
+
+        private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
+        {
+            if (!_localFileSystem.FileExists(path))
+            {
+                return BaseError.New($"{name} path does not exist");
+            }
+
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = path,
+                Arguments = "-version",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false
+            };
+
+            var test = new Process
+            {
+                StartInfo = startInfo
+            };
+
+            test.Start();
+            string output = await test.StandardOutput.ReadToEndAsync();
+            await test.WaitForExitAsync();
+            return test.ExitCode == 0 && output.Contains($"{name} version")
+                ? Unit.Default
+                : BaseError.New($"Unable to verify {name} version");
+        }
+
+        private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
+        {
+            await _configElementRepository.Get(ConfigElementKey.FFmpegPath).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.FFmpegPath;
@@ -35,7 +84,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
-            ffprobePath.Match(
+            await _configElementRepository.Get(ConfigElementKey.FFprobePath).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.FFprobePath;
@@ -48,7 +97,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
-            defaultFFmpegProfileId.Match(
+            await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId).Match(
                 ce =>
                 {
                     ce.Value = request.Settings.DefaultFFmpegProfileId.ToString();
@@ -64,7 +113,45 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     _configElementRepository.Add(ce);
                 });
 
-            return Unit.Value;
+            await _configElementRepository.Get(ConfigElementKey.FFmpegSaveReports).Match(
+                ce =>
+                {
+                    ce.Value = request.Settings.SaveReports.ToString();
+                    _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement
+                    {
+                        Key = ConfigElementKey.FFmpegSaveReports.Key,
+                        Value = request.Settings.SaveReports.ToString()
+                    };
+                    _configElementRepository.Add(ce);
+                });
+
+            if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
+            {
+                Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
+            }
+
+            await _configElementRepository.Get(ConfigElementKey.FFmpegPreferredLanguageCode).Match(
+                ce =>
+                {
+                    ce.Value = request.Settings.PreferredLanguageCode;
+                    _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement
+                    {
+                        Key = ConfigElementKey.FFmpegPreferredLanguageCode.Key,
+                        Value = request.Settings.PreferredLanguageCode
+                    };
+                    _configElementRepository.Add(ce);
+                });
+
+
+            return Unit.Default;
         }
     }
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -1,4 +1,5 @@
 using ErsatzTV.Application.Resolutions;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.FFmpegProfiles
 {
@@ -7,6 +8,7 @@ namespace ErsatzTV.Application.FFmpegProfiles
         string Name,
         int ThreadCount,
         bool Transcode,
+        HardwareAccelerationKind HardwareAcceleration,
         ResolutionViewModel Resolution,
         bool NormalizeResolution,
         string VideoCodec,

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -5,5 +5,7 @@
         public string FFmpegPath { get; set; }
         public string FFprobePath { get; set; }
         public int DefaultFFmpegProfileId { get; set; }
+        public string PreferredLanguageCode { get; set; }
+        public bool SaveReports { get; set; }
     }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -11,6 +11,7 @@ namespace ErsatzTV.Application.FFmpegProfiles
                 profile.Name,
                 profile.ThreadCount,
                 profile.Transcode,
+                profile.HardwareAcceleration,
                 Project(profile.Resolution),
                 profile.NormalizeResolution,
                 profile.VideoCodec,

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -22,12 +22,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
             Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath);
             Option<int> defaultFFmpegProfileId =
                 await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId);
+            Option<bool> saveReports =
+                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
+            Option<string> preferredLanguageCode =
+                await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
 
             return new FFmpegSettingsViewModel
             {
                 FFmpegPath = ffmpegPath.IfNone(string.Empty),
                 FFprobePath = ffprobePath.IfNone(string.Empty),
-                DefaultFFmpegProfileId = defaultFFmpegProfileId.IfNone(0)
+                DefaultFFmpegProfileId = defaultFFmpegProfileId.IfNone(0),
+                SaveReports = saveReports.IfNone(false),
+                PreferredLanguageCode = preferredLanguageCode.IfNone("eng")
             };
         }
     }

ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs

@@ -1,9 +1,10 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
 
 namespace ErsatzTV.Application.Images.Commands
 {
     // ReSharper disable once SuggestBaseTypeForParameter
-    public record SaveImageToDisk(byte[] Buffer) : IRequest<Either<BaseError, string>>;
+    public record SaveArtworkToDisk(byte[] Buffer, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
 }

ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Images;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Images.Commands
+{
+    public class SaveArtworkToDiskHandler : IRequestHandler<SaveArtworkToDisk, Either<BaseError, string>>
+    {
+        private readonly IImageCache _imageCache;
+
+        public SaveArtworkToDiskHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+        public Task<Either<BaseError, string>> Handle(SaveArtworkToDisk request, CancellationToken cancellationToken) =>
+            _imageCache.SaveArtworkToCache(request.Buffer, request.ArtworkKind);
+    }
+}

ErsatzTV.Application/Images/Commands/SaveImageToDiskHandler.cs

@@ -1,43 +0,0 @@
-using System;
-using System.IO;
-using System.Security.Cryptography;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.Images.Commands
-{
-    public class SaveImageToDiskHandler : IRequestHandler<SaveImageToDisk, Either<BaseError, string>>
-    {
-        private static readonly SHA1CryptoServiceProvider Crypto;
-
-        static SaveImageToDiskHandler() => Crypto = new SHA1CryptoServiceProvider();
-
-        public async Task<Either<BaseError, string>> Handle(
-            SaveImageToDisk request,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
-                byte[] hash = Crypto.ComputeHash(request.Buffer);
-                string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
-
-                string fileName = Path.Combine(FileSystemLayout.ImageCacheFolder, hex);
-
-                if (!Directory.Exists(FileSystemLayout.ImageCacheFolder))
-                {
-                    Directory.CreateDirectory(FileSystemLayout.ImageCacheFolder);
-                }
-
-                await File.WriteAllBytesAsync(fileName, request.Buffer, cancellationToken);
-                return hex;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-    }
-}

ErsatzTV.Application/Images/Queries/GetImageContents.cs

@@ -1,8 +1,10 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
 
 namespace ErsatzTV.Application.Images.Queries
 {
-    public record GetImageContents(string FileName) : IRequest<Either<BaseError, ImageViewModel>>;
+    public record GetImageContents
+        (string FileName, ArtworkKind ArtworkKind, int? MaxHeight = null) : IRequest<Either<BaseError, ImageViewModel>>;
 }

ErsatzTV.Application/Images/Queries/GetImageContentsHandler.cs

@@ -3,6 +3,8 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
 using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Caching.Memory;
@@ -13,9 +15,14 @@ namespace ErsatzTV.Application.Images.Queries
     public class GetImageContentsHandler : IRequestHandler<GetImageContents, Either<BaseError, ImageViewModel>>
     {
         private static readonly MimeTypes MimeTypes = new();
+        private readonly IImageCache _imageCache;
         private readonly IMemoryCache _memoryCache;
 
-        public GetImageContentsHandler(IMemoryCache memoryCache) => _memoryCache = memoryCache;
+        public GetImageContentsHandler(IImageCache imageCache, IMemoryCache memoryCache)
+        {
+            _imageCache = imageCache;
+            _memoryCache = memoryCache;
+        }
 
         public async Task<Either<BaseError, ImageViewModel>> Handle(
             GetImageContents request,
@@ -29,8 +36,26 @@ namespace ErsatzTV.Application.Images.Queries
                     {
                         entry.SlidingExpiration = TimeSpan.FromHours(1);
 
-                        string fileName = Path.Combine(FileSystemLayout.ImageCacheFolder, request.FileName);
+                        string subfolder = request.FileName.Substring(0, 2);
+                        string baseFolder = request.ArtworkKind switch
+                        {
+                            ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
+                            ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
+                            ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
+                            ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
+                            _ => FileSystemLayout.LegacyImageCacheFolder
+                        };
+
+                        string fileName = Path.Combine(baseFolder, request.FileName);
                         byte[] contents = await File.ReadAllBytesAsync(fileName, cancellationToken);
+
+                        if (request.MaxHeight.HasValue)
+                        {
+                            Either<BaseError, byte[]> resizeResult = await _imageCache
+                                .ResizeImage(contents, request.MaxHeight.Value);
+                            resizeResult.IfRight(result => contents = result);
+                        }
+
                         MimeType mimeType = MimeTypes.GetMimeType(contents);
                         return new ImageViewModel(contents, mimeType.Name);
                     });

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPath.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record CreateLocalLibraryPath
+        (int LibraryId, string Path) : IRequest<Either<BaseError, LocalLibraryPathViewModel>>;
+}

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static LanguageExt.Prelude;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class CreateLocalLibraryPathHandler : IRequestHandler<CreateLocalLibraryPath,
+        Either<BaseError, LocalLibraryPathViewModel>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public CreateLocalLibraryPathHandler(ILibraryRepository mediaSourceRepository) =>
+            _libraryRepository = mediaSourceRepository;
+
+        public Task<Either<BaseError, LocalLibraryPathViewModel>> Handle(
+            CreateLocalLibraryPath request,
+            CancellationToken cancellationToken) =>
+            Validate(request).MapT(PersistLocalLibraryPath).Bind(v => v.ToEitherAsync());
+
+        private Task<LocalLibraryPathViewModel> PersistLocalLibraryPath(LibraryPath p) =>
+            _libraryRepository.Add(p).Map(ProjectToViewModel);
+
+        private Task<Validation<BaseError, LibraryPath>> Validate(CreateLocalLibraryPath request) =>
+            ValidateFolder(request)
+                .MapT(
+                    folder =>
+                        new LibraryPath
+                        {
+                            LibraryId = request.LibraryId,
+                            Path = folder
+                        });
+
+        private async Task<Validation<BaseError, string>> ValidateFolder(CreateLocalLibraryPath request)
+        {
+            List<string> allPaths = await _libraryRepository.GetLocalPaths(request.LibraryId)
+                .Map(list => list.Map(c => c.Path).ToList());
+
+
+            return Optional(request.Path)
+                .Filter(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
+                .ToValidation<BaseError>("Path must not belong to another library path");
+        }
+
+        private static bool AreSubPaths(string path1, string path2)
+        {
+            string one = path1 + Path.DirectorySeparatorChar;
+            string two = path2 + Path.DirectorySeparatorChar;
+            return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
+                   two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPath.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record DeleteLocalLibraryPath(int LocalLibraryPathId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class
+        DeleteLocalLibraryPathHandler : MediatR.IRequestHandler<DeleteLocalLibraryPath, Either<BaseError, Unit>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository, ISearchIndex searchIndex)
+        {
+            _libraryRepository = libraryRepository;
+            _searchIndex = searchIndex;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            DeleteLocalLibraryPath request,
+            CancellationToken cancellationToken) =>
+            MediaSourceMustExist(request)
+                .MapT(DoDeletion)
+                .Bind(t => t.ToEitherAsync());
+
+        private async Task<Unit> DoDeletion(LibraryPath libraryPath)
+        {
+            List<int> ids = await _libraryRepository.GetMediaIdsByLocalPath(libraryPath.Id);
+            await _searchIndex.RemoveItems(ids);
+            await _libraryRepository.DeleteLocalPath(libraryPath.Id);
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, LibraryPath>> MediaSourceMustExist(DeleteLocalLibraryPath request) =>
+            (await _libraryRepository.GetPath(request.LocalLibraryPathId))
+            .HeadOrNone()
+            .ToValidation<BaseError>(
+                $"Local library path {request.LocalLibraryPathId} does not exist.");
+    }
+}

ErsatzTV.Application/Libraries/LibraryViewModel.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Libraries
+{
+    public record LibraryViewModel(string LibraryKind, int Id, string Name, LibraryMediaKind MediaKind);
+}

ErsatzTV.Application/Libraries/LocalLibraryPathViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Libraries
+{
+    public record LocalLibraryPathViewModel(int Id, int LibraryId, string Path);
+}

ErsatzTV.Application/Libraries/LocalLibraryViewModel.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Libraries
+{
+    public record LocalLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
+        : LibraryViewModel("Local", Id, Name, MediaKind);
+}

ErsatzTV.Application/Libraries/Mapper.cs

@@ -0,0 +1,22 @@
+using System;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Libraries
+{
+    internal static class Mapper
+    {
+        public static LibraryViewModel ProjectToViewModel(Library library) =>
+            library switch
+            {
+                LocalLibrary l => ProjectToViewModel(l),
+                PlexLibrary p => new PlexLibraryViewModel(p.Id, p.Name, p.MediaKind),
+                _ => throw new ArgumentOutOfRangeException(nameof(library))
+            };
+
+        public static LocalLibraryViewModel ProjectToViewModel(LocalLibrary library) =>
+            new(library.Id, library.Name, library.MediaKind);
+
+        public static LocalLibraryPathViewModel ProjectToViewModel(LibraryPath libraryPath) =>
+            new(libraryPath.Id, libraryPath.LibraryId, libraryPath.Path);
+    }
+}

ErsatzTV.Application/Libraries/PlexLibraryViewModel.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Libraries
+{
+    public record PlexLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
+        : LibraryViewModel("Plex", Id, Name, MediaKind);
+}

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPath.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record CountMediaItemsByLibraryPath(int LibraryPathId) : IRequest<int>;
+}

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPathHandler.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class CountMediaItemsByLibraryPathHandler : IRequestHandler<CountMediaItemsByLibraryPath, int>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public CountMediaItemsByLibraryPathHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
+
+        public Task<int> Handle(CountMediaItemsByLibraryPath request, CancellationToken cancellationToken) =>
+            _libraryRepository.CountMediaItemsByPath(request.LibraryPathId);
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetAllLibraries.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record GetAllLibraries : IRequest<List<LibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class GetAllLibrariesHandler : IRequestHandler<GetAllLibraries, List<LibraryViewModel>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public GetAllLibrariesHandler(ILibraryRepository libraryRepository) => _libraryRepository = libraryRepository;
+
+        public Task<List<LibraryViewModel>> Handle(GetAllLibraries request, CancellationToken cancellationToken) =>
+            _libraryRepository.GetAll()
+                .Map(list => list.Filter(ShouldIncludeLibrary).Map(ProjectToViewModel).ToList());
+
+        private static bool ShouldIncludeLibrary(Library library) =>
+            library switch
+            {
+                LocalLibrary => true,
+                PlexLibrary plex => plex.ShouldSyncItems,
+                _ => false
+            };
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetLocalLibraryById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record GetLocalLibraryById(int LibraryId) : IRequest<Option<LocalLibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Queries/GetLocalLibraryByIdHandler.cs

@@ -0,0 +1,22 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class GetLocalLibraryByIdHandler : IRequestHandler<GetLocalLibraryById, Option<LocalLibraryViewModel>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public GetLocalLibraryByIdHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
+
+        public Task<Option<LocalLibraryViewModel>> Handle(
+            GetLocalLibraryById request,
+            CancellationToken cancellationToken) =>
+            _libraryRepository.GetLocal(request.LibraryId).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPaths.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record GetLocalLibraryPaths(int LocalLibraryId) : IRequest<List<LocalLibraryPathViewModel>>;
+}

ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPathsHandler.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class GetLocalLibraryPathsHandler : IRequestHandler<GetLocalLibraryPaths, List<LocalLibraryPathViewModel>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public GetLocalLibraryPathsHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
+
+        public Task<List<LocalLibraryPathViewModel>> Handle(
+            GetLocalLibraryPaths request,
+            CancellationToken cancellationToken) =>
+            _libraryRepository.GetLocalPaths(request.LocalLibraryId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Logs/LogEntryViewModel.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace ErsatzTV.Application.Logs
+{
+    public record LogEntryViewModel(
+        int Id,
+        DateTime Timestamp,
+        string Level,
+        string Exception,
+        string RenderedMessage,
+        string Properties);
+}

ErsatzTV.Application/Logs/Mapper.cs

@@ -0,0 +1,16 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Logs
+{
+    internal static class Mapper
+    {
+        internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry) =>
+            new(
+                logEntry.Id,
+                logEntry.Timestamp,
+                logEntry.Level,
+                logEntry.Exception,
+                logEntry.RenderedMessage,
+                logEntry.Properties);
+    }
+}

ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Logs.Queries
+{
+    public record GetRecentLogEntries : IRequest<List<LogEntryViewModel>>;
+}

ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Logs.Mapper;
+
+namespace ErsatzTV.Application.Logs.Queries
+{
+    public class GetRecentLogEntriesHandler : IRequestHandler<GetRecentLogEntries, List<LogEntryViewModel>>
+    {
+        private readonly ILogRepository _logRepository;
+
+        public GetRecentLogEntriesHandler(ILogRepository logRepository) => _logRepository = logRepository;
+
+        public Task<List<LogEntryViewModel>> Handle(GetRecentLogEntries request, CancellationToken cancellationToken) =>
+            _logRepository.GetRecentLogEntries().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record CollectionCardResultsViewModel(
+        string Name,
+        List<MovieCardViewModel> MovieCards,
+        List<TelevisionShowCardViewModel> ShowCards,
+        List<TelevisionSeasonCardViewModel> SeasonCards,
+        List<TelevisionEpisodeCardViewModel> EpisodeCards)
+    {
+        public bool UseCustomPlaybackOrder { get; set; }
+    }
+}

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    internal static class Mapper
+    {
+        internal static TelevisionShowCardViewModel ProjectToViewModel(ShowMetadata showMetadata) =>
+            new(
+                showMetadata.ShowId,
+                showMetadata.Title,
+                showMetadata.Year?.ToString(),
+                showMetadata.SortTitle,
+                GetPoster(showMetadata));
+
+        internal static TelevisionSeasonCardViewModel ProjectToViewModel(Season season) =>
+            new(
+                season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
+                season.Id,
+                season.SeasonNumber,
+                GetSeasonName(season.SeasonNumber),
+                string.Empty,
+                GetSeasonName(season.SeasonNumber),
+                season.SeasonMetadata.HeadOrNone().Map(GetPoster).IfNone(string.Empty),
+                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
+
+        internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
+            EpisodeMetadata episodeMetadata) =>
+            new(
+                episodeMetadata.EpisodeId,
+                episodeMetadata.ReleaseDate ?? DateTime.MinValue,
+                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
+                    m => m.Title ?? string.Empty,
+                    () => string.Empty),
+                episodeMetadata.Episode.Season.ShowId,
+                episodeMetadata.Episode.SeasonId,
+                episodeMetadata.Episode.EpisodeNumber,
+                episodeMetadata.Title,
+                episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
+                    em => em.Plot ?? string.Empty,
+                    () => string.Empty),
+                GetThumbnail(episodeMetadata));
+
+        internal static MovieCardViewModel ProjectToViewModel(MovieMetadata movieMetadata) =>
+            new(
+                movieMetadata.MovieId,
+                movieMetadata.Title,
+                movieMetadata.Year?.ToString(),
+                movieMetadata.SortTitle,
+                GetPoster(movieMetadata));
+
+        internal static CollectionCardResultsViewModel
+            ProjectToViewModel(Collection collection) =>
+            new(
+                collection.Name,
+                collection.MediaItems.OfType<Movie>().Map(
+                    m => ProjectToViewModel(m.MovieMetadata.Head()) with
+                    {
+                        CustomIndex = GetCustomIndex(collection, m.Id)
+                    }).ToList(),
+                collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList(),
+                collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
+                collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
+                    .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
+
+        private static int GetCustomIndex(Collection collection, int mediaItemId) =>
+            Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
+                .Map(ci => ci.CustomIndex ?? 0)
+                .IfNone(0);
+
+        internal static SearchCardResultsViewModel ProjectToSearchResults(List<MediaItem> items) =>
+            new(
+                items.OfType<Movie>().Map(m => ProjectToViewModel(m.MovieMetadata.Head())).ToList(),
+                items.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList());
+
+        private static string GetSeasonName(int number) =>
+            number == 0 ? "Specials" : $"Season {number}";
+
+        private static string GetPoster(Metadata metadata) =>
+            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
+                .Match(a => a.Path, string.Empty);
+
+        private static string GetThumbnail(Metadata metadata) =>
+            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
+                .Match(a => a.Path, string.Empty);
+    }
+}

ErsatzTV.Application/MediaCards/MediaCardViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MediaCardViewModel(int MediaItemId, string Title, string Subtitle, string SortTitle, string Poster);
+}

ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MovieCardResultsViewModel(int Count, List<MovieCardViewModel> Cards, Option<SearchPageMap> PageMap);
+}

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

@@ -0,0 +1,13 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MovieCardViewModel
+        (int MovieId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            MovieId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster)
+    {
+        public int CustomIndex { get; set; }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetCollectionCards.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public record GetCollectionCards(int Id) : IRequest<Either<BaseError, CollectionCardResultsViewModel>>;
+}

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -0,0 +1,26 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class GetCollectionCardsHandler : IRequestHandler<GetCollectionCards,
+        Either<BaseError, CollectionCardResultsViewModel>>
+    {
+        private readonly IMediaCollectionRepository _collectionRepository;
+
+        public GetCollectionCardsHandler(IMediaCollectionRepository collectionRepository) =>
+            _collectionRepository = collectionRepository;
+
+        public Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
+            GetCollectionCards request,
+            CancellationToken cancellationToken) =>
+            _collectionRepository.GetCollectionWithItemsUntracked(request.Id)
+                .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
+                .MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCards.cs

@@ -0,0 +1,7 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public record GetTelevisionEpisodeCards
+        (int TelevisionSeasonId, int PageNumber, int PageSize) : IRequest<TelevisionEpisodeCardResultsViewModel>;
+}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class
+        GetTelevisionEpisodeCardsHandler : IRequestHandler<GetTelevisionEpisodeCards,
+            TelevisionEpisodeCardResultsViewModel>
+    {
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public GetTelevisionEpisodeCardsHandler(ITelevisionRepository televisionRepository) =>
+            _televisionRepository = televisionRepository;
+
+        public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
+            GetTelevisionEpisodeCards request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _televisionRepository.GetEpisodeCount(request.TelevisionSeasonId);
+
+            List<TelevisionEpisodeCardViewModel> results = await _televisionRepository
+                .GetPagedEpisodes(request.TelevisionSeasonId, request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new TelevisionEpisodeCardResultsViewModel(count, results);
+        }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCards.cs

@@ -0,0 +1,7 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public record GetTelevisionSeasonCards
+        (int TelevisionShowId, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
+}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class
+        GetTelevisionSeasonCardsHandler : IRequestHandler<GetTelevisionSeasonCards, TelevisionSeasonCardResultsViewModel
+        >
+    {
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public GetTelevisionSeasonCardsHandler(ITelevisionRepository televisionRepository) =>
+            _televisionRepository = televisionRepository;
+
+        public async Task<TelevisionSeasonCardResultsViewModel> Handle(
+            GetTelevisionSeasonCards request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _televisionRepository.GetSeasonCount(request.TelevisionShowId);
+
+            List<TelevisionSeasonCardViewModel> results = await _televisionRepository
+                .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new TelevisionSeasonCardResultsViewModel(count, results);
+        }
+    }
+}

ErsatzTV.Application/MediaCards/SearchCardResultsViewModel.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record SearchCardResultsViewModel(
+        List<MovieCardViewModel> MovieCards,
+        List<TelevisionShowCardViewModel> ShowCards);
+}

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionEpisodeCardResultsViewModel(int Count, List<TelevisionEpisodeCardViewModel> Cards);
+}

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionEpisodeCardViewModel
+    (
+        int EpisodeId,
+        DateTime Aired,
+        string ShowTitle,
+        int ShowId,
+        int SeasonId,
+        int Episode,
+        string Title,
+        string Plot,
+        string Poster) : MediaCardViewModel(
+        EpisodeId,
+        Title,
+        $"Episode {Episode}",
+        $"Episode {Episode}",
+        Poster)
+    {
+    }
+}

ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionSeasonCardResultsViewModel(int Count, List<TelevisionSeasonCardViewModel> Cards);
+}

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -0,0 +1,20 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionSeasonCardViewModel
+    (
+        string ShowTitle,
+        int TelevisionSeasonId,
+        int TelevisionSeasonNumber,
+        string Title,
+        string Subtitle,
+        string SortTitle,
+        string Poster,
+        string Placeholder) : MediaCardViewModel(
+        TelevisionSeasonId,
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster)
+    {
+    }
+}

ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionShowCardResultsViewModel(
+        int Count,
+        List<TelevisionShowCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionShowCardViewModel
+        (int TelevisionShowId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            TelevisionShowId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster)
+    {
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollection.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddEpisodeToCollection(int CollectionId, int EpisodeId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs

@@ -0,0 +1,67 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddEpisodeToCollectionHandler : MediatR.IRequestHandler<AddEpisodeToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public AddEpisodeToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ITelevisionRepository televisionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _televisionRepository = televisionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddEpisodeToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddTelevisionEpisodeRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddTelevisionEpisodeRequest(AddEpisodeToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.EpisodeId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddEpisodeToCollection request) =>
+            (await CollectionMustExist(request), await ValidateEpisode(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddEpisodeToCollection request) =>
+            _mediaCollectionRepository.Get(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateEpisode(AddEpisodeToCollection request) =>
+            LoadTelevisionEpisode(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Episode does not exist"));
+
+        private Task<Option<int>> LoadTelevisionEpisode(AddEpisodeToCollection request) =>
+            _televisionRepository.GetEpisode(request.EpisodeId).MapT(e => e.Id);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddItemsToCollection
+        (int CollectionId, List<int> MovieIds, List<int> ShowIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -0,0 +1,80 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddItemsToCollectionHandler : MediatR.IRequestHandler<AddItemsToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly IMovieRepository _movieRepository;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public AddItemsToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IMovieRepository movieRepository,
+            ITelevisionRepository televisionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _movieRepository = movieRepository;
+            _televisionRepository = televisionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddItemsToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddItemsRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddItemsRequest(AddItemsToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItems(
+                request.CollectionId,
+                request.MovieIds.Append(request.ShowIds).ToList()))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddItemsToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMovies(request), await ValidateShows(request))
+            .Apply((_, _, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddItemsToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateMovies(AddItemsToCollection request) =>
+            _movieRepository.AllMoviesExist(request.MovieIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
+
+        private Task<Validation<BaseError, Unit>> ValidateShows(AddItemsToCollection request) =>
+            _televisionRepository.AllShowsExist(request.ShowIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Show does not exist"));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddMovieCollection.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddMovieToCollection(int CollectionId, int MovieId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs

@@ -0,0 +1,68 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddMovieToCollectionHandler : MediatR.IRequestHandler<AddMovieToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly IMovieRepository _movieRepository;
+
+        public AddMovieToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IMovieRepository movieRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _movieRepository = movieRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddMovieToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddMoviesRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddMoviesRequest(AddMovieToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.MovieId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddMovieToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMovies(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddMovieToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateMovies(AddMovieToCollection request) =>
+            LoadMovie(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
+
+        private Task<Option<Movie>> LoadMovie(AddMovieToCollection request) =>
+            _movieRepository.GetMovie(request.MovieId);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollection.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddSeasonToCollection(int CollectionId, int SeasonId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs

@@ -0,0 +1,69 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddSeasonToCollectionHandler : MediatR.IRequestHandler<AddSeasonToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public AddSeasonToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ITelevisionRepository televisionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _televisionRepository = televisionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddSeasonToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddTelevisionSeasonRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddTelevisionSeasonRequest(AddSeasonToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.SeasonId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddSeasonToCollection request) =>
+            (await CollectionMustExist(request), await ValidateSeason(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddSeasonToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateSeason(AddSeasonToCollection request) =>
+            LoadTelevisionSeason(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Season does not exist"));
+
+        private Task<Option<Season>> LoadTelevisionSeason(
+            AddSeasonToCollection request) =>
+            _televisionRepository.GetSeason(request.SeasonId);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddShowToCollection.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddShowToCollection(int CollectionId, int ShowId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs

@@ -0,0 +1,69 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddShowToCollectionHandler : MediatR.IRequestHandler<AddShowToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public AddShowToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ITelevisionRepository televisionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _televisionRepository = televisionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddShowToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddTelevisionShowRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddTelevisionShowRequest(AddShowToCollection request)
+        {
+            var result = new Unit();
+
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.ShowId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return result;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddShowToCollection request) =>
+            (await CollectionMustExist(request), await ValidateShow(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddShowToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateShow(AddShowToCollection request) =>
+            LoadTelevisionShow(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Show does not exist"));
+
+        private Task<Option<Show>> LoadTelevisionShow(AddShowToCollection request) =>
+            _televisionRepository.GetShow(request.ShowId);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/CreateCollection.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record CreateCollection(string Name) : IRequest<Either<BaseError, MediaCollectionViewModel>>;
+}

ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs

@@ -12,28 +12,33 @@ using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
-    public class CreateSimpleMediaCollectionHandler : IRequestHandler<CreateSimpleMediaCollection,
-        Either<BaseError, MediaCollectionViewModel>>
+    public class
+        CreateCollectionHandler : IRequestHandler<CreateCollection, Either<BaseError, MediaCollectionViewModel>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public CreateSimpleMediaCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public CreateCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
             _mediaCollectionRepository = mediaCollectionRepository;
 
         public Task<Either<BaseError, MediaCollectionViewModel>> Handle(
-            CreateSimpleMediaCollection request,
+            CreateCollection request,
             CancellationToken cancellationToken) =>
             Validate(request).MapT(PersistCollection).Bind(v => v.ToEitherAsync());
 
-        private Task<MediaCollectionViewModel> PersistCollection(SimpleMediaCollection c) =>
+        private Task<MediaCollectionViewModel> PersistCollection(Collection c) =>
             _mediaCollectionRepository.Add(c).Map(ProjectToViewModel);
 
-        private Task<Validation<BaseError, SimpleMediaCollection>> Validate(CreateSimpleMediaCollection request) =>
-            ValidateName(request).MapT(name => new SimpleMediaCollection { Name = name });
+        private Task<Validation<BaseError, Collection>> Validate(CreateCollection request) =>
+            ValidateName(request).MapT(
+                name => new Collection
+                {
+                    Name = name,
+                    MediaItems = new List<MediaItem>()
+                });
 
-        private async Task<Validation<BaseError, string>> ValidateName(CreateSimpleMediaCollection createCollection)
+        private async Task<Validation<BaseError, string>> ValidateName(CreateCollection createCollection)
         {
-            List<string> allNames = await _mediaCollectionRepository.GetSimpleMediaCollections()
+            List<string> allNames = await _mediaCollectionRepository.GetAll()
                 .Map(list => list.Map(c => c.Name).ToList());
 
             Validation<BaseError, string> result1 = createCollection.NotEmpty(c => c.Name)
@@ -41,7 +46,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
 
             var result2 = Optional(createCollection.Name)
                 .Filter(name => !allNames.Contains(name))
-                .ToValidation<BaseError>("Media collection name must be unique");
+                .ToValidation<BaseError>("Collection name must be unique");
 
             return (result1, result2).Apply((_, _) => createCollection.Name);
         }

ErsatzTV.Application/MediaCollections/Commands/CreateSimpleMediaCollection.cs

@@ -1,9 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record CreateSimpleMediaCollection
-        (string Name) : IRequest<Either<BaseError, MediaCollectionViewModel>>;
-}

ErsatzTV.Application/MediaCollections/Commands/DeleteCollection.cs

@@ -5,5 +5,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
-    public record DeleteSimpleMediaCollection(int SimpleMediaCollectionId) : IRequest<Either<BaseError, Task>>;
+    public record DeleteCollection(int CollectionId) : IRequest<Either<BaseError, Task>>;
 }

ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs

@@ -7,28 +7,27 @@ using MediatR;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
-    public class
-        DeleteSimpleMediaCollectionHandler : IRequestHandler<DeleteSimpleMediaCollection, Either<BaseError, Task>>
+    public class DeleteCollectionHandler : IRequestHandler<DeleteCollection, Either<BaseError, Task>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public DeleteSimpleMediaCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public DeleteCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
             _mediaCollectionRepository = mediaCollectionRepository;
 
         public async Task<Either<BaseError, Task>> Handle(
-            DeleteSimpleMediaCollection request,
+            DeleteCollection request,
             CancellationToken cancellationToken) =>
-            (await SimpleMediaCollectionMustExist(request))
+            (await CollectionMustExist(request))
             .Map(DoDeletion)
             .ToEither<Task>();
 
         private Task DoDeletion(int mediaCollectionId) => _mediaCollectionRepository.Delete(mediaCollectionId);
 
-        private async Task<Validation<BaseError, int>> SimpleMediaCollectionMustExist(
-            DeleteSimpleMediaCollection deleteMediaCollection) =>
-            (await _mediaCollectionRepository.GetSimpleMediaCollection(deleteMediaCollection.SimpleMediaCollectionId))
+        private async Task<Validation<BaseError, int>> CollectionMustExist(
+            DeleteCollection deleteMediaCollection) =>
+            (await _mediaCollectionRepository.Get(deleteMediaCollection.CollectionId))
             .ToValidation<BaseError>(
-                $"SimpleMediaCollection {deleteMediaCollection.SimpleMediaCollectionId} does not exist.")
+                $"Collection {deleteMediaCollection.CollectionId} does not exist.")
             .Map(c => c.Id);
     }
 }

ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollection.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record RemoveItemsFromCollection(int MediaCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>
+    {
+        public List<int> MediaItemIds { get; set; } = new();
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs

@@ -0,0 +1,65 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        RemoveItemsFromCollectionHandler : MediatR.IRequestHandler<RemoveItemsFromCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public RemoveItemsFromCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            RemoveItemsFromCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(collection => ApplyRemoveItemsRequest(request, collection))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyRemoveItemsRequest(
+            RemoveItemsFromCollection request,
+            Collection collection)
+        {
+            var itemsToRemove = collection.MediaItems
+                .Filter(m => request.MediaItemIds.Contains(m.Id))
+                .ToList();
+
+            itemsToRemove.ForEach(m => collection.MediaItems.Remove(m));
+
+            if (itemsToRemove.Any() && await _mediaCollectionRepository.Update(collection))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private Task<Validation<BaseError, Collection>> Validate(
+            RemoveItemsFromCollection request) =>
+            CollectionMustExist(request);
+
+        private Task<Validation<BaseError, Collection>> CollectionMustExist(
+            RemoveItemsFromCollection updateCollection) =>
+            _mediaCollectionRepository.GetCollectionWithItems(updateCollection.MediaCollectionId)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/ReplaceSimpleMediaCollectionItems.cs

@@ -1,11 +0,0 @@
-using System.Collections.Generic;
-using ErsatzTV.Application.MediaItems;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record ReplaceSimpleMediaCollectionItems
-        (int MediaCollectionId, List<int> MediaItemIds) : IRequest<Either<BaseError, List<MediaItemViewModel>>>;
-}

ErsatzTV.Application/MediaCollections/Commands/ReplaceSimpleMediaCollectionItemsHandler.cs

@@ -1,65 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaItems;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using LanguageExt.UnsafeValueAccess;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public class ReplaceSimpleMediaCollectionItemsHandler : IRequestHandler<ReplaceSimpleMediaCollectionItems,
-        Either<BaseError, List<MediaItemViewModel>>>
-    {
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-        private readonly IMediaItemRepository _mediaItemRepository;
-
-        public ReplaceSimpleMediaCollectionItemsHandler(
-            IMediaCollectionRepository mediaCollectionRepository,
-            IMediaItemRepository mediaItemRepository)
-        {
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _mediaItemRepository = mediaItemRepository;
-        }
-
-        public Task<Either<BaseError, List<MediaItemViewModel>>> Handle(
-            ReplaceSimpleMediaCollectionItems request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(mediaItems => PersistItems(request, mediaItems))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<List<MediaItemViewModel>> PersistItems(
-            ReplaceSimpleMediaCollectionItems request,
-            List<MediaItem> mediaItems)
-        {
-            await _mediaCollectionRepository.ReplaceItems(request.MediaCollectionId, mediaItems);
-            return mediaItems.Map(MediaItems.Mapper.ProjectToViewModel).ToList();
-        }
-
-        private Task<Validation<BaseError, List<MediaItem>>> Validate(ReplaceSimpleMediaCollectionItems request) =>
-            MediaCollectionMustExist(request).BindT(_ => MediaItemsMustExist(request));
-
-        private async Task<Validation<BaseError, SimpleMediaCollection>> MediaCollectionMustExist(
-            ReplaceSimpleMediaCollectionItems request) =>
-            (await _mediaCollectionRepository.GetSimpleMediaCollection(request.MediaCollectionId))
-            .ToValidation<BaseError>("[MediaCollectionId] does not exist.");
-
-        private async Task<Validation<BaseError, List<MediaItem>>> MediaItemsMustExist(
-            ReplaceSimpleMediaCollectionItems replaceItems)
-        {
-            var allMediaItems = (await replaceItems.MediaItemIds.Map(i => _mediaItemRepository.Get(i)).Sequence())
-                .ToList();
-            if (allMediaItems.Any(x => x.IsNone))
-            {
-                return BaseError.New("[MediaItemId] does not exist");
-            }
-
-            return allMediaItems.Sequence().ValueUnsafe().ToList();
-        }
-    }
-}

ErsatzTV.Application/MediaCollections/Commands/UpdateChannelHandler.cs

@@ -1,47 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public class
-        UpdateSimpleMediaCollectionHandler : MediatR.IRequestHandler<UpdateSimpleMediaCollection,
-            Either<BaseError, Unit>>
-    {
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public UpdateSimpleMediaCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
-            _mediaCollectionRepository = mediaCollectionRepository;
-
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateSimpleMediaCollection request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(c => ApplyUpdateRequest(c, request))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Unit> ApplyUpdateRequest(SimpleMediaCollection c, UpdateSimpleMediaCollection update)
-        {
-            c.Name = update.Name;
-            await _mediaCollectionRepository.Update(c);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, SimpleMediaCollection>>
-            Validate(UpdateSimpleMediaCollection request) =>
-            (await SimpleMediaCollectionMustExist(request), ValidateName(request))
-            .Apply((simpleMediaCollectionToUpdate, _) => simpleMediaCollectionToUpdate);
-
-        private Task<Validation<BaseError, SimpleMediaCollection>> SimpleMediaCollectionMustExist(
-            UpdateSimpleMediaCollection updateSimpleMediaCollection) =>
-            _mediaCollectionRepository.GetSimpleMediaCollection(updateSimpleMediaCollection.MediaCollectionId)
-                .Map(v => v.ToValidation<BaseError>("SimpleMediaCollection does not exist."));
-
-        private Validation<BaseError, string> ValidateName(UpdateSimpleMediaCollection updateSimpleMediaCollection) =>
-            updateSimpleMediaCollection.NotEmpty(c => c.Name)
-                .Bind(_ => updateSimpleMediaCollection.NotLongerThan(50)(c => c.Name));
-    }
-}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs

@@ -0,0 +1,12 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateCollection
+        (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>
+    {
+        public Option<bool> UseCustomPlaybackOrder { get; set; } = None;
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateCollectionCustomOrder
+    (
+        int CollectionId,
+        List<MediaItemCustomOrder> MediaItemCustomOrders) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record MediaItemCustomOrder(int MediaItemId, int CustomIndex);
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        UpdateCollectionCustomOrderHandler : MediatR.IRequestHandler<UpdateCollectionCustomOrder,
+            Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateCollectionCustomOrderHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateCollectionCustomOrder request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(c => ApplyUpdateRequest(c, request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollectionCustomOrder request)
+        {
+            foreach (MediaItemCustomOrder updateItem in request.MediaItemCustomOrders)
+            {
+                Option<CollectionItem> maybeCollectionItem =
+                    c.CollectionItems.FirstOrDefault(ci => ci.MediaItemId == updateItem.MediaItemId);
+
+                maybeCollectionItem.IfSome(ci => ci.CustomIndex = updateItem.CustomIndex);
+            }
+
+            if (await _mediaCollectionRepository.Update(c))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
+                    request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private Task<Validation<BaseError, Collection>> Validate(UpdateCollectionCustomOrder request) =>
+            CollectionMustExist(request);
+
+        private Task<Validation<BaseError, Collection>> CollectionMustExist(
+            UpdateCollectionCustomOrder request) =>
+            _mediaCollectionRepository.Get(request.CollectionId)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -0,0 +1,64 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(c => ApplyUpdateRequest(c, request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollection request)
+        {
+            c.Name = request.Name;
+            request.UseCustomPlaybackOrder.IfSome(
+                useCustomPlaybackOrder => c.UseCustomPlaybackOrder = useCustomPlaybackOrder);
+            if (await _mediaCollectionRepository.Update(c) && request.UseCustomPlaybackOrder.IsSome)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
+                    request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Collection>>
+            Validate(UpdateCollection request) =>
+            (await CollectionMustExist(request), ValidateName(request))
+            .Apply((collectionToUpdate, _) => collectionToUpdate);
+
+        private Task<Validation<BaseError, Collection>> CollectionMustExist(
+            UpdateCollection updateCollection) =>
+            _mediaCollectionRepository.Get(updateCollection.CollectionId)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Validation<BaseError, string> ValidateName(UpdateCollection updateSimpleMediaCollection) =>
+            updateSimpleMediaCollection.NotEmpty(c => c.Name)
+                .Bind(_ => updateSimpleMediaCollection.NotLongerThan(50)(c => c.Name));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateSimpleMediaCollection.cs

@@ -1,8 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record UpdateSimpleMediaCollection
-        (int MediaCollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>;
-}

ErsatzTV.Application/MediaCollections/Mapper.cs

@@ -1,19 +1,10 @@
-using ErsatzTV.Core.AggregateModels;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaCollections
 {
     internal static class Mapper
     {
-        internal static MediaCollectionViewModel ProjectToViewModel(MediaCollection mediaCollection) =>
-            new(mediaCollection.Id, mediaCollection.Name);
-
-        internal static MediaCollectionSummaryViewModel ProjectToViewModel(
-            MediaCollectionSummary mediaCollectionSummary) =>
-            new(
-                mediaCollectionSummary.Id,
-                mediaCollectionSummary.Name,
-                mediaCollectionSummary.ItemCount,
-                mediaCollectionSummary.IsSimple);
+        internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
+            new(collection.Id, collection.Name);
     }
 }

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

@@ -1,4 +1,11 @@
-namespace ErsatzTV.Application.MediaCollections
+using ErsatzTV.Application.MediaCards;
+
+namespace ErsatzTV.Application.MediaCollections
 {
-    public record MediaCollectionViewModel(int Id, string Name);
+    public record MediaCollectionViewModel(int Id, string Name) : MediaCardViewModel(
+        Id,
+        Name,
+        string.Empty,
+        Name,
+        string.Empty);
 }

ErsatzTV.Application/MediaCollections/Queries/GetAllCollections.cs

@@ -3,5 +3,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.MediaCollections.Queries
 {
-    public record GetAllMediaCollections : IRequest<List<MediaCollectionViewModel>>;
+    public record GetAllCollections : IRequest<List<MediaCollectionViewModel>>;
 }

ErsatzTV.Application/MediaCollections/Queries/GetAllCollectionsHandler.cs

@@ -9,15 +9,15 @@ using static ErsatzTV.Application.MediaCollections.Mapper;
 
 namespace ErsatzTV.Application.MediaCollections.Queries
 {
-    public class GetAllMediaCollectionsHandler : IRequestHandler<GetAllMediaCollections, List<MediaCollectionViewModel>>
+    public class GetAllCollectionsHandler : IRequestHandler<GetAllCollections, List<MediaCollectionViewModel>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public GetAllMediaCollectionsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public GetAllCollectionsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
             _mediaCollectionRepository = mediaCollectionRepository;
 
         public Task<List<MediaCollectionViewModel>> Handle(
-            GetAllMediaCollections request,
+            GetAllCollections request,
             CancellationToken cancellationToken) =>
             _mediaCollectionRepository.GetAll().Map(list => list.Map(ProjectToViewModel).ToList());
     }

ErsatzTV.Application/MediaCollections/Queries/GetAllSimpleMediaCollections.cs

@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetAllSimpleMediaCollections : IRequest<List<MediaCollectionViewModel>>;
-}

ErsatzTV.Application/MediaCollections/Queries/GetAllSimpleMediaCollectionsHandler.cs

@@ -1,25 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using MediatR;
-using static ErsatzTV.Application.MediaCollections.Mapper;
-
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public class
-        GetAllSimpleMediaCollectionsHandler : IRequestHandler<GetAllSimpleMediaCollections,
-            List<MediaCollectionViewModel>>
-    {
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public GetAllSimpleMediaCollectionsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
-            _mediaCollectionRepository = mediaCollectionRepository;
-
-        public async Task<List<MediaCollectionViewModel>> Handle(
-            GetAllSimpleMediaCollections request,
-            CancellationToken cancellationToken) =>
-            (await _mediaCollectionRepository.GetSimpleMediaCollections()).Map(ProjectToViewModel).ToList();
-    }
-}

ErsatzTV.Application/MediaCollections/Queries/GetCollectionById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public record GetCollectionById(int Id) : IRequest<Option<MediaCollectionViewModel>>;
+}

ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs

@@ -8,18 +8,18 @@ using static ErsatzTV.Application.MediaCollections.Mapper;
 namespace ErsatzTV.Application.MediaCollections.Queries
 {
     public class
-        GetSimpleMediaCollectionByIdHandler : IRequestHandler<GetSimpleMediaCollectionById,
+        GetCollectionByIdHandler : IRequestHandler<GetCollectionById,
             Option<MediaCollectionViewModel>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public GetSimpleMediaCollectionByIdHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public GetCollectionByIdHandler(IMediaCollectionRepository mediaCollectionRepository) =>
             _mediaCollectionRepository = mediaCollectionRepository;
 
         public Task<Option<MediaCollectionViewModel>> Handle(
-            GetSimpleMediaCollectionById request,
+            GetCollectionById request,
             CancellationToken cancellationToken) =>
-            _mediaCollectionRepository.GetSimpleMediaCollection(request.Id)
+            _mediaCollectionRepository.Get(request.Id)
                 .MapT(ProjectToViewModel);
     }
 }

ErsatzTV.Application/MediaCollections/Queries/GetCollectionItems.cs

@@ -5,5 +5,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.MediaCollections.Queries
 {
-    public record GetSimpleMediaCollectionItems(int Id) : IRequest<Option<IEnumerable<MediaItemViewModel>>>;
+    public record GetCollectionItems(int Id) : IRequest<Option<IEnumerable<MediaItemViewModel>>>;
 }

ErsatzTV.Application/MediaCollections/Queries/GetCollectionItemsHandler.cs

@@ -9,18 +9,18 @@ using static ErsatzTV.Application.MediaItems.Mapper;
 
 namespace ErsatzTV.Application.MediaCollections.Queries
 {
-    public class GetSimpleMediaCollectionItemsHandler : IRequestHandler<GetSimpleMediaCollectionItems,
+    public class GetCollectionItemsHandler : IRequestHandler<GetCollectionItems,
         Option<IEnumerable<MediaItemViewModel>>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
 
-        public GetSimpleMediaCollectionItemsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+        public GetCollectionItemsHandler(IMediaCollectionRepository mediaCollectionRepository) =>
             _mediaCollectionRepository = mediaCollectionRepository;
 
         public Task<Option<IEnumerable<MediaItemViewModel>>> Handle(
-            GetSimpleMediaCollectionItems request,
+            GetCollectionItems request,
             CancellationToken cancellationToken) =>
-            _mediaCollectionRepository.GetSimpleMediaCollectionItems(request.Id)
+            _mediaCollectionRepository.GetItems(request.Id)
                 .MapT(mediaItems => mediaItems.Map(ProjectToViewModel));
     }
 }