more docker tag tweaks [no ci]

* test docker build and push

* enable for test branch

* try to get tag another way

* add nvidia and vaapi pushes

* try to get tag again

* still looking for the tag

* include sha in version

* only build and push docker on merges to main

* push docker images on release

* add hw accel info to readme

.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,81 @@ 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
+        uses: docker/setup-buildx-action@v1
+
+      - name: Cache Docker layers
+        uses: actions/cache@v2.1.4
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+
+      - 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:
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:develop
+            jasongdove/ersatztv:${{ github.sha }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          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
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          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
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max

.github/workflows/release.yml

@@ -39,30 +39,105 @@ 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
         with:
+          prerelease: true
           files: |
             ErsatzTV*.zip
             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
+        uses: docker/setup-buildx-action@v1
+
+      - name: Cache Docker layers
+        uses: actions/cache@v2.1.4
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+
+      - 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:
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:latest
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          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
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          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
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max

Directory.Build.props

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

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -36,10 +37,29 @@ namespace ErsatzTV.Application.Channels.Commands
         private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
             (ValidateName(request), ValidateNumber(request), await FFmpegProfileMustExist(request))
             .Apply(
-                (name, number, ffmpegProfileId) => new Channel(Guid.NewGuid())
+                (name, number, ffmpegProfileId) =>
                 {
-                    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
+                    };
                 });
 
         private Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,4 +1,7 @@
-using System.Threading;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -6,6 +9,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,7 +31,33 @@ namespace ErsatzTV.Application.Channels.Commands
             c.Name = update.Name;
             c.Number = update.Number;
             c.FFmpegProfileId = update.FFmpegProfileId;
-            c.Logo = update.Logo;
+
+            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);

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,10 +1,22 @@
-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.StreamingMode);
+
+        private static string GetLogo(Channel channel) =>
+            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+                .Match(a => a.Path, string.Empty);
     }
 }

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/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/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/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,25 @@ 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),
+                            _ => 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,34 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class
+        DeleteLocalLibraryPathHandler : MediatR.IRequestHandler<DeleteLocalLibraryPath, Either<BaseError, Unit>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
+
+        public Task<Either<BaseError, Unit>> Handle(
+            DeleteLocalLibraryPath request,
+            CancellationToken cancellationToken) =>
+            MediaSourceMustExist(request)
+                .MapT(DoDeletion)
+                .Bind(t => t.ToEitherAsync());
+
+        private Task<Unit> DoDeletion(LibraryPath libraryPath) =>
+            _libraryRepository.DeleteLocalPath(libraryPath.Id).ToUnit();
+
+        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,11 @@
+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);
+}

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -0,0 +1,76 @@
+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().Map(m => m.Title).IfNone(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().Map(m => m.Title).IfNone(string.Empty),
+                episodeMetadata.Title,
+                $"Episode {episodeMetadata.Episode.EpisodeNumber}",
+                episodeMetadata.Episode.EpisodeNumber.ToString(),
+                GetThumbnail(episodeMetadata),
+                episodeMetadata.Episode.EpisodeNumber.ToString());
+
+        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())).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());
+
+        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(string Title, string Subtitle, string SortTitle, string Poster);
+}

ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

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

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 async Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
+            GetCollectionCards request,
+            CancellationToken cancellationToken) =>
+            (await _collectionRepository.GetCollectionWithItemsUntracked(request.Id))
+            .ToEither(BaseError.New("Unable to load collection"))
+            .Map(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetMovieCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetMovieCardsHandler.cs

@@ -0,0 +1,30 @@
+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
+        GetMovieCardsHandler : IRequestHandler<GetMovieCards, MovieCardResultsViewModel>
+    {
+        private readonly IMovieRepository _movieRepository;
+
+        public GetMovieCardsHandler(IMovieRepository movieRepository) => _movieRepository = movieRepository;
+
+        public async Task<MovieCardResultsViewModel> Handle(GetMovieCards request, CancellationToken cancellationToken)
+        {
+            int count = await _movieRepository.GetMovieCount();
+
+            List<MovieCardViewModel> results = await _movieRepository
+                .GetPagedMovies(request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new MovieCardResultsViewModel(count, results);
+        }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetSearchCards.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public record GetSearchCards(string Query) : IRequest<Either<BaseError, SearchCardResultsViewModel>>;
+}

ErsatzTV.Application/MediaCards/Queries/GetSearchCardsHandler.cs

@@ -0,0 +1,25 @@
+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;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class GetSearchCardsHandler : IRequestHandler<GetSearchCards, Either<BaseError, SearchCardResultsViewModel>>
+    {
+        private readonly ISearchRepository _searchRepository;
+
+        public GetSearchCardsHandler(ISearchRepository searchRepository) => _searchRepository = searchRepository;
+
+        public Task<Either<BaseError, SearchCardResultsViewModel>> Handle(
+            GetSearchCards request,
+            CancellationToken cancellationToken) =>
+            Try(_searchRepository.SearchMediaItems(request.Query)).Sequence()
+                .Map(ProjectToSearchResults)
+                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
+    }
+}

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/Queries/GetTelevisionShowCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetTelevisionShowCardsHandler.cs

@@ -0,0 +1,33 @@
+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
+        GetTelevisionShowCardsHandler : IRequestHandler<GetTelevisionShowCards, TelevisionShowCardResultsViewModel>
+    {
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public GetTelevisionShowCardsHandler(ITelevisionRepository televisionRepository) =>
+            _televisionRepository = televisionRepository;
+
+        public async Task<TelevisionShowCardResultsViewModel> Handle(
+            GetTelevisionShowCards request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _televisionRepository.GetShowCount();
+
+            List<TelevisionShowCardViewModel> results = await _televisionRepository
+                .GetPagedShows(request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new TelevisionShowCardResultsViewModel(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,21 @@
+using System;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionEpisodeCardViewModel
+    (
+        int EpisodeId,
+        DateTime Aired,
+        string ShowTitle,
+        string Title,
+        string Subtitle,
+        string SortTitle,
+        string Poster,
+        string Placeholder) : MediaCardViewModel(
+        Title,
+        Subtitle,
+        SortTitle,
+        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,19 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionSeasonCardViewModel
+    (
+        string ShowTitle,
+        int TelevisionSeasonId,
+        int TelevisionSeasonNumber,
+        string Title,
+        string Subtitle,
+        string SortTitle,
+        string Poster,
+        string Placeholder) : MediaCardViewModel(
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster)
+    {
+    }
+}

ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record TelevisionShowCardViewModel
+        (int TelevisionShowId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            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/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,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateCollection
+        (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -0,0 +1,45 @@
+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 UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
+    {
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateCollectionHandler(IMediaCollectionRepository mediaCollectionRepository) =>
+            _mediaCollectionRepository = mediaCollectionRepository;
+
+        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 update)
+        {
+            c.Name = update.Name;
+            await _mediaCollectionRepository.Update(c);
+            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,10 @@
-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(
+        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));
     }
 }

ErsatzTV.Application/MediaCollections/Queries/GetMediaCollectionSummaries.cs

@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetMediaCollectionSummaries(string SearchString) : IRequest<List<MediaCollectionSummaryViewModel>>;
-}

ErsatzTV.Application/MediaCollections/Queries/GetMediaCollectionSummariesHandler.cs

@@ -1,27 +0,0 @@
-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.MediaCollections.Mapper;
-
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public class
-        GetMediaCollectionSummariesHandler : IRequestHandler<GetMediaCollectionSummaries,
-            List<MediaCollectionSummaryViewModel>>
-    {
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public GetMediaCollectionSummariesHandler(IMediaCollectionRepository mediaCollectionRepository) =>
-            _mediaCollectionRepository = mediaCollectionRepository;
-
-        public Task<List<MediaCollectionSummaryViewModel>> Handle(
-            GetMediaCollectionSummaries request,
-            CancellationToken cancellationToken) =>
-            _mediaCollectionRepository.GetSummaries(request.SearchString)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}

ErsatzTV.Application/MediaCollections/Queries/GetSimpleMediaCollectionById.cs

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

ErsatzTV.Application/MediaItems/AggregateMediaItemViewModel.cs

@@ -1,4 +0,0 @@
-namespace ErsatzTV.Application.MediaItems
-{
-    public record AggregateMediaItemViewModel(string Source, string Title, int Count, string Duration);
-}

ErsatzTV.Application/MediaItems/Commands/CreateMediaItem.cs

@@ -1,8 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.MediaItems.Commands
-{
-    public record CreateMediaItem(int MediaSourceId, string Path) : IRequest<Either<BaseError, MediaItemViewModel>>;
-}

ErsatzTV.Application/MediaItems/Commands/CreateMediaItemHandler.cs

@@ -1,96 +0,0 @@
-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 static LanguageExt.Prelude;
-using static ErsatzTV.Application.MediaItems.Mapper;
-
-namespace ErsatzTV.Application.MediaItems.Commands
-{
-    public class CreateMediaItemHandler : IRequestHandler<CreateMediaItem, Either<BaseError, MediaItemViewModel>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly IMediaItemRepository _mediaItemRepository;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISmartCollectionBuilder _smartCollectionBuilder;
-
-        public CreateMediaItemHandler(
-            IMediaItemRepository mediaItemRepository,
-            IMediaSourceRepository mediaSourceRepository,
-            IConfigElementRepository configElementRepository,
-            ISmartCollectionBuilder smartCollectionBuilder,
-            ILocalMetadataProvider localMetadataProvider,
-            ILocalStatisticsProvider localStatisticsProvider)
-        {
-            _mediaItemRepository = mediaItemRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-            _configElementRepository = configElementRepository;
-            _smartCollectionBuilder = smartCollectionBuilder;
-            _localMetadataProvider = localMetadataProvider;
-            _localStatisticsProvider = localStatisticsProvider;
-        }
-
-        public Task<Either<BaseError, MediaItemViewModel>> Handle(
-            CreateMediaItem request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(PersistMediaItem)
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<MediaItemViewModel> PersistMediaItem(RequestParameters parameters)
-        {
-            await _mediaItemRepository.Add(parameters.MediaItem);
-
-            await _localStatisticsProvider.RefreshStatistics(parameters.FFprobePath, parameters.MediaItem);
-            await _localMetadataProvider.RefreshMetadata(parameters.MediaItem);
-            await _smartCollectionBuilder.RefreshSmartCollections(parameters.MediaItem);
-
-            return ProjectToViewModel(parameters.MediaItem);
-        }
-
-        private async Task<Validation<BaseError, RequestParameters>> Validate(CreateMediaItem request) =>
-            (await ValidateMediaSource(request), PathMustExist(request), await ValidateFFprobePath())
-            .Apply(
-                (mediaSourceId, path, ffprobePath) => new RequestParameters(
-                    ffprobePath,
-                    new MediaItem
-                    {
-                        MediaSourceId = mediaSourceId,
-                        Path = path
-                    }));
-
-        private async Task<Validation<BaseError, int>> ValidateMediaSource(CreateMediaItem createMediaItem) =>
-            (await MediaSourceMustExist(createMediaItem)).Bind(MediaSourceMustBeLocal);
-
-        private async Task<Validation<BaseError, MediaSource>> MediaSourceMustExist(CreateMediaItem createMediaItem) =>
-            (await _mediaSourceRepository.Get(createMediaItem.MediaSourceId))
-            .ToValidation<BaseError>($"[MediaSource] {createMediaItem.MediaSourceId} does not exist.");
-
-        private Validation<BaseError, int> MediaSourceMustBeLocal(MediaSource mediaSource) =>
-            Some(mediaSource)
-                .Filter(ms => ms is LocalMediaSource)
-                .ToValidation<BaseError>($"[MediaSource] {mediaSource.Id} must be a local media source")
-                .Map(ms => ms.Id);
-
-        private Validation<BaseError, string> PathMustExist(CreateMediaItem createMediaItem) =>
-            Some(createMediaItem.Path)
-                .Filter(File.Exists)
-                .ToValidation<BaseError>("[Path] does not exist on the file system");
-
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private record RequestParameters(string FFprobePath, MediaItem MediaItem);
-    }
-}