handle unauthorized jellyfin server (#186)

* wip

* start to add jellyfin tables to db

* code cleanup

* finish adding jellyfin media source

* sync jellyfin libraries

* display list of jellyfin libraries

* toggle jellyfin library sync

* edit jellyfin path replacements

* noop jellyfin scanners

* get jellyfin admin user id on startup

* implement jellyfin disconnect

* add jellyfin libraries to list; start to query jellyfin library items

* code cleanup

* start to project jellyfin movies

* save new jellyfin movies to db

* basic jellyfin movie update

* load jellyfin actor artwork

* load jellyfin movie poster and fan art

* more jellyfin artwork fixes, sync audio streams

* jellyfin playback sort of works

* skip jellyfin movies that are inaccessible

* use ffprobe for jellyfin movie statistics

* code cleanup

* store jellyfin operating system

* more jellyfin movie updates

* update jellyfin movie poster and fan art

* add jellyfin tv types

* sync jellyfin shows

* sync jellyfin seasons

* sync jellyfin episodes

* remove missing jellyfin television items

* delete empty jellyfin seasons and shows

* fix jellyfin updates

* fix indexing jellyfin movie and show languages

.editorconfig

@@ -79,3 +79,7 @@ indent_size=2
 indent_style=space
 indent_size=4
 tab_width=4
+
+[*.yml]
+indent_style = space
+indent_size = 2

.github/workflows/ci.yml

@@ -1,5 +1,6 @@
 name: Build
 on:
+  workflow_dispatch:
   pull_request:
   push:
     branches:
@@ -35,7 +36,7 @@ jobs:
     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]')
+    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no docker]')
     steps:
       - name: Checkout
         uses: actions/checkout@v2
@@ -51,16 +52,17 @@ jobs:
           final="${tag2/prealpha/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
 
-      - name: Set up Docker Buildx
+      - name: Set up Docker Buildx Base
         uses: docker/setup-buildx-action@v1
+        id: builder-base
 
-      - 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: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
 
       - name: Login to DockerHub
         uses: docker/login-action@v1
@@ -71,6 +73,7 @@ jobs:
       - name: Build and push base
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-base.outputs.name }}
           context: .
           file: ./docker/Dockerfile
           push: true
@@ -79,19 +82,11 @@ jobs:
           tags: |
             jasongdove/ersatztv:develop
             jasongdove/ersatztv:${{ github.sha }}
-          cache-from: type=local,src=/tmp/.buildx-cache
-          cache-to: type=local,dest=/tmp/.buildx-cache-new
-      - # Temporary fix
-        # https://github.com/docker/build-push-action/issues/252
-        # https://github.com/moby/buildkit/issues/1896
-        name: Move cache
-        run: |
-          rm -rf /tmp/.buildx-cache
-          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
 
       - name: Build and push nvidia
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
           context: .
           file: ./docker/nvidia/Dockerfile
           push: true
@@ -100,12 +95,11 @@ jobs:
           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:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
           context: .
           file: ./docker/vaapi/Dockerfile
           push: true
@@ -114,5 +108,3 @@ jobs:
           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/docs.yml

@@ -0,0 +1,19 @@
+name: Publish docs via GitHub Pages
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Deploy docs
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout master
+        uses: actions/checkout@v1
+
+      - name: Deploy docs
+        uses: mhausenblas/mkdocs-deploy-gh-pages@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CUSTOM_DOMAIN: ersatztv.org

.github/workflows/release.yml

@@ -83,16 +83,17 @@ jobs:
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
           echo "DOCKER_TAG=${tag/-prealpha/}" >> $GITHUB_ENV
 
-      - name: Set up Docker Buildx
+      - name: Set up Docker Buildx Base
         uses: docker/setup-buildx-action@v1
+        id: builder-base
 
-      - 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: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
 
       - name: Login to DockerHub
         uses: docker/login-action@v1
@@ -103,6 +104,7 @@ jobs:
       - name: Build and push base
         uses: docker/build-push-action@v2
         with:
+          builder: ${{ steps.builder-base.outputs.name }}
           context: .
           file: ./docker/Dockerfile
           push: true
@@ -111,12 +113,11 @@ jobs:
           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:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
           context: .
           file: ./docker/nvidia/Dockerfile
           push: true
@@ -125,12 +126,11 @@ jobs:
           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:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
           context: .
           file: ./docker/vaapi/Dockerfile
           push: true
@@ -139,5 +139,3 @@ jobs:
           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

.gitignore

@@ -40,3 +40,6 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+
+docker-compose.override.yml
+

ErsatzTV.Application/Artists/ArtistViewModel.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace ErsatzTV.Application.Artists
+{
+    public record ArtistViewModel(
+        string Name,
+        string Disambiguation,
+        string Biography,
+        string Thumbnail,
+        string FanArt,
+        List<string> Genres,
+        List<string> Styles,
+        List<string> Moods,
+        List<CultureInfo> Languages);
+}

ErsatzTV.Application/Artists/Mapper.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Artists
+{
+    internal static class Mapper
+    {
+        internal static ArtistViewModel ProjectToViewModel(Artist artist, List<string> languages)
+        {
+            ArtistMetadata metadata = Optional(artist.ArtistMetadata).Flatten().Head();
+            return new ArtistViewModel(
+                metadata.Title,
+                metadata.Disambiguation,
+                metadata.Biography,
+                Artwork(metadata, ArtworkKind.Thumbnail),
+                Artwork(metadata, ArtworkKind.FanArt),
+                metadata.Genres.Map(g => g.Name).ToList(),
+                metadata.Styles.Map(s => s.Name).ToList(),
+                metadata.Moods.Map(m => m.Name).ToList(),
+                LanguagesForArtist(languages));
+        }
+
+        private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>
+            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+                .Match(a => a.Path, string.Empty);
+
+        private static List<CultureInfo> LanguagesForArtist(List<string> languages)
+        {
+            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+            return languages
+                .Distinct()
+                .Map(
+                    lang => allCultures.Filter(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+                .Sequence()
+                .Flatten()
+                .ToList();
+        }
+    }
+}

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public record GetArtistById(int ArtistId) : IRequest<Option<ArtistViewModel>>;
+}

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Artists.Mapper;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
+    {
+        private readonly IArtistRepository _artistRepository;
+        private readonly ISearchRepository _searchRepository;
+
+        public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
+        {
+            _artistRepository = artistRepository;
+            _searchRepository = searchRepository;
+        }
+
+        public async Task<Option<ArtistViewModel>> Handle(
+            GetArtistById request,
+            CancellationToken cancellationToken)
+        {
+            Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
+            return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
+                async artist =>
+                {
+                    List<string> languages = await _searchRepository.GetLanguagesForArtist(artist);
+                    return ProjectToViewModel(artist, languages);
+                },
+                () => Task.FromResult(Option<ArtistViewModel>.None));
+        }
+    }
+}

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -8,5 +8,6 @@ namespace ErsatzTV.Application.Channels
         string Name,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -11,5 +11,6 @@ namespace ErsatzTV.Application.Channels.Commands
         string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,6 +11,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Channels.Commands
 {
@@ -36,9 +39,10 @@ namespace ErsatzTV.Application.Channels.Commands
             _channelRepository.Add(c).Map(ProjectToViewModel);
 
         private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
-            (ValidateName(request), await ValidateNumber(request), await FFmpegProfileMustExist(request))
+            (ValidateName(request), await ValidateNumber(request), await FFmpegProfileMustExist(request),
+                ValidatePreferredLanguage(request))
             .Apply(
-                (name, number, ffmpegProfileId) =>
+                (name, number, ffmpegProfileId, preferredLanguageCode) =>
                 {
                     var artwork = new List<Artwork>();
                     if (!string.IsNullOrWhiteSpace(request.Logo))
@@ -59,7 +63,8 @@ namespace ErsatzTV.Application.Channels.Commands
                         Number = number,
                         FFmpegProfileId = ffmpegProfileId,
                         StreamingMode = request.StreamingMode,
-                        Artwork = artwork
+                        Artwork = artwork,
+                        PreferredLanguageCode = preferredLanguageCode
                     };
                 });
 
@@ -67,6 +72,13 @@ namespace ErsatzTV.Application.Channels.Commands
             createChannel.NotEmpty(c => c.Name)
                 .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
+        private Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
+            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
+
         private async Task<Validation<BaseError, string>> ValidateNumber(CreateChannel createChannel)
         {
             Option<Channel> maybeExistingChannel = await _channelRepository.GetByNumber(createChannel.Number);

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -12,5 +12,6 @@ namespace ErsatzTV.Application.Channels.Commands
         string Number,
         int FFmpegProfileId,
         string Logo,
+        string PreferredLanguageCode,
         StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -32,6 +33,7 @@ namespace ErsatzTV.Application.Channels.Commands
             c.Name = update.Name;
             c.Number = update.Number;
             c.FFmpegProfileId = update.FFmpegProfileId;
+            c.PreferredLanguageCode = update.PreferredLanguageCode;
 
             if (!string.IsNullOrWhiteSpace(update.Logo))
             {
@@ -65,8 +67,9 @@ namespace ErsatzTV.Application.Channels.Commands
         }
 
         private async Task<Validation<BaseError, Channel>> Validate(UpdateChannel request) =>
-            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request))
-            .Apply((channelToUpdate, _, _) => channelToUpdate);
+            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request),
+                ValidatePreferredLanguage(request))
+            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
 
         private Task<Validation<BaseError, Channel>> ChannelMustExist(UpdateChannel updateChannel) =>
             _channelRepository.Get(updateChannel.ChannelId)
@@ -79,7 +82,7 @@ namespace ErsatzTV.Application.Channels.Commands
         private async Task<Validation<BaseError, string>> ValidateNumber(UpdateChannel updateChannel)
         {
             Option<Channel> match = await _channelRepository.GetByNumber(updateChannel.Number);
-            int matchId = match.Map(c => c.Id).IfNone(updateChannel.ChannelId);
+            int matchId = await match.Map(c => c.Id).IfNoneAsync(updateChannel.ChannelId);
             if (matchId == updateChannel.ChannelId)
             {
                 if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
@@ -92,5 +95,12 @@ namespace ErsatzTV.Application.Channels.Commands
 
             return BaseError.New("Channel number must be unique");
         }
+
+        private Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+                .Filter(
+                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+                .ToValidation<BaseError>("Preferred language code is invalid");
     }
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -13,6 +13,7 @@ namespace ErsatzTV.Application.Channels
                 channel.Name,
                 channel.FFmpegProfileId,
                 GetLogo(channel),
+                channel.PreferredLanguageCode,
                 channel.StreamingMode);
 
         private static string GetLogo(Channel channel) =>

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : MediatR.IRequest<Unit>;
+}

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -0,0 +1,34 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public class SaveConfigElementByKeyHandler : MediatR.IRequestHandler<SaveConfigElementByKey, Unit>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
+        {
+            Option<ConfigElement> maybeElement = await _configElementRepository.Get(request.Key);
+            await maybeElement.Match(
+                ce =>
+                {
+                    ce.Value = request.Value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = request.Key.Key, Value = request.Value };
+                    return _configElementRepository.Add(ce);
+                });
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -0,0 +1,47 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public class
+        UpdateLibraryRefreshIntervalHandler : MediatR.IRequestHandler<UpdateLibraryRefreshInterval,
+            Either<BaseError, Unit>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateLibraryRefreshInterval request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval.ToString()))
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
+            Optional(request.LibraryRefreshInterval)
+                .Filter(lri => lri > 0)
+                .Map(_ => Unit.Default)
+                .ToValidation<BaseError>("Tuner count must be greater than zero")
+                .AsTask();
+
+        private Task<Unit> Upsert(ConfigElementKey key, string value) =>
+            _configElementRepository.Get(key).Match(
+                ce =>
+                {
+                    ce.Value = value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = key.Key, Value = value };
+                    return _configElementRepository.Add(ce);
+                }).ToUnit();
+    }
+}

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Configuration
+{
+    public record ConfigElementViewModel(string Key, string Value);
+}

ErsatzTV.Application/Configuration/Mapper.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Configuration
+{
+    internal static class Mapper
+    {
+        internal static ConfigElementViewModel ProjectToViewModel(ConfigElement element) =>
+            new(element.Key, element.Value);
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public record GetConfigElementByKey(ConfigElementKey Key) : IRequest<Option<ConfigElementViewModel>>;
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.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.Configuration.Mapper;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<Option<ConfigElementViewModel>> Handle(
+            GetConfigElementByKey request,
+            CancellationToken cancellationToken) =>
+            _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public record GetLibraryRefreshInterval : IRequest<int>;
+}

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

@@ -0,0 +1,21 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Configuration.Queries
+{
+    public class GetLibraryRefreshIntervalHandler : IRequestHandler<GetLibraryRefreshInterval, int>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public GetLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<int> Handle(GetLibraryRefreshInterval request, CancellationToken cancellationToken) =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+                .Map(result => result.IfNone(6));
+    }
+}

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -2,11 +2,20 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="MediatR" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.FFmpegProfiles.Commands
+{
+    public record CopyFFmpegProfile
+        (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+}

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs

@@ -0,0 +1,37 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.FFmpegProfiles.Mapper;
+
+namespace ErsatzTV.Application.FFmpegProfiles.Commands
+{
+    public class
+        CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
+    {
+        private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
+
+        public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
+            _ffmpegProfileRepository = ffmpegProfileRepository;
+
+        public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
+            CopyFFmpegProfile request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(PerformCopy)
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
+            _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
+                .Map(ProjectToViewModel);
+
+        private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
+            ValidateName(request).AsTask().MapT(_ => request);
+
+        private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
+            request.NotEmpty(x => x.Name)
+                .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+    }
+}

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -11,17 +11,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -43,19 +43,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     Transcode = request.Transcode,
                     HardwareAcceleration = request.HardwareAcceleration,
                     ResolutionId = resolutionId,
-                    NormalizeResolution = request.NormalizeResolution,
+                    NormalizeVideo = request.NormalizeVideo,
                     VideoCodec = request.VideoCodec,
-                    NormalizeVideoCodec = request.NormalizeVideoCodec,
                     VideoBitrate = request.VideoBitrate,
                     VideoBufferSize = request.VideoBufferSize,
                     AudioCodec = request.AudioCodec,
-                    NormalizeAudioCodec = request.NormalizeAudioCodec,
                     AudioBitrate = request.AudioBitrate,
                     AudioBufferSize = request.AudioBufferSize,
-                    AudioVolume = request.AudioVolume,
+                    NormalizeLoudness = request.NormalizeLoudness,
                     AudioChannels = request.AudioChannels,
                     AudioSampleRate = request.AudioSampleRate,
-                    NormalizeAudio = request.NormalizeAudio
+                    NormalizeAudio = request.NormalizeAudio,
+                    FrameRate = request.FrameRate
                 });
 
         private Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
@@ -63,7 +62,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => createFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
-            createFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(CreateFFmpegProfile createFFmpegProfile) =>
             (await _resolutionRepository.Get(createFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -12,17 +12,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -37,19 +37,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.Transcode = update.Transcode;
             p.HardwareAcceleration = update.HardwareAcceleration;
             p.ResolutionId = update.ResolutionId;
-            p.NormalizeResolution = update.NormalizeResolution;
+            p.NormalizeVideo = update.NormalizeVideo;
             p.VideoCodec = update.VideoCodec;
-            p.NormalizeVideoCodec = update.NormalizeVideoCodec;
             p.VideoBitrate = update.VideoBitrate;
             p.VideoBufferSize = update.VideoBufferSize;
             p.AudioCodec = update.AudioCodec;
-            p.NormalizeAudioCodec = update.NormalizeAudioCodec;
             p.AudioBitrate = update.AudioBitrate;
             p.AudioBufferSize = update.AudioBufferSize;
-            p.AudioVolume = update.AudioVolume;
+            p.NormalizeLoudness = update.NormalizeLoudness;
             p.AudioChannels = update.AudioChannels;
             p.AudioSampleRate = update.AudioSampleRate;
             p.NormalizeAudio = update.NormalizeAudio;
+            p.FrameRate = update.FrameRate;
             await _ffmpegProfileRepository.Update(p);
             return ProjectToViewModel(p);
         }
@@ -69,7 +68,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
-            updateFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(UpdateFFmpegProfile updateFFmpegProfile) =>
             (await _resolutionRepository.Get(updateFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -70,54 +71,35 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
 
         private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
         {
-            Option<ConfigElement> ffmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
-            Option<ConfigElement> ffprobePath = await _configElementRepository.Get(ConfigElementKey.FFprobePath);
-            Option<ConfigElement> defaultFFmpegProfileId =
-                await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId);
+            await Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
+            await Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
+            await Upsert(ConfigElementKey.FFmpegDefaultProfileId, request.Settings.DefaultFFmpegProfileId.ToString());
+            await Upsert(ConfigElementKey.FFmpegSaveReports, request.Settings.SaveReports.ToString());
 
-            ffmpegPath.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFmpegPath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFmpegPath.Key, Value = request.Settings.FFmpegPath };
-                    _configElementRepository.Add(ce);
-                });
+            if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
+            {
+                Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
+            }
 
-            ffprobePath.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFprobePath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFprobePath.Key, Value = request.Settings.FFprobePath };
-                    _configElementRepository.Add(ce);
-                });
-
-            defaultFFmpegProfileId.Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.DefaultFFmpegProfileId.ToString();
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                    {
-                        Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
-                        Value = request.Settings.DefaultFFmpegProfileId.ToString()
-                    };
-                    _configElementRepository.Add(ce);
-                });
+            await Upsert(ConfigElementKey.FFmpegPreferredLanguageCode, request.Settings.PreferredLanguageCode);
 
             return Unit.Default;
         }
+
+        private async Task Upsert(ConfigElementKey key, string value)
+        {
+            Option<ConfigElement> maybeElement = await _configElementRepository.Get(key);
+            await maybeElement.Match(
+                ce =>
+                {
+                    ce.Value = value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = key.Key, Value = value };
+                    return _configElementRepository.Add(ce);
+                });
+        }
     }
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -10,17 +10,16 @@ namespace ErsatzTV.Application.FFmpegProfiles
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         ResolutionViewModel Resolution,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio);
+        bool NormalizeAudio,
+        string FrameRate);
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

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

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -13,19 +13,18 @@ namespace ErsatzTV.Application.FFmpegProfiles
                 profile.Transcode,
                 profile.HardwareAcceleration,
                 Project(profile.Resolution),
-                profile.NormalizeResolution,
+                profile.NormalizeVideo,
                 profile.VideoCodec,
-                profile.NormalizeVideoCodec,
                 profile.VideoBitrate,
                 profile.VideoBufferSize,
                 profile.AudioCodec,
-                profile.NormalizeAudioCodec,
                 profile.AudioBitrate,
                 profile.AudioBufferSize,
-                profile.AudioVolume,
+                profile.NormalizeLoudness,
                 profile.AudioChannels,
                 profile.AudioSampleRate,
-                profile.NormalizeAudio);
+                profile.NormalizeAudio,
+                profile.FrameRate);
 
         private static ResolutionViewModel Project(Resolution resolution) =>
             new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

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

ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCount.cs

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

ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.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;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.HDHR.Commands
+{
+    public class UpdateHDHRTunerCountHandler : MediatR.IRequestHandler<UpdateHDHRTunerCount, Either<BaseError, Unit>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public UpdateHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateHDHRTunerCount request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => Upsert(ConfigElementKey.HDHRTunerCount, request.TunerCount.ToString()))
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Validation<BaseError, Unit>> Validate(UpdateHDHRTunerCount request) =>
+            Optional(request.TunerCount)
+                .Filter(tc => tc > 0)
+                .Map(_ => Unit.Default)
+                .ToValidation<BaseError>("Tuner count must be greater than zero")
+                .AsTask();
+
+        private Task<Unit> Upsert(ConfigElementKey key, string value) =>
+            _configElementRepository.Get(key).Match(
+                ce =>
+                {
+                    ce.Value = value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = key.Key, Value = value };
+                    return _configElementRepository.Add(ce);
+                }).ToUnit();
+    }
+}

ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCount.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.HDHR.Queries
+{
+    public record GetHDHRTunerCount : IRequest<int>;
+}

ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCountHandler.cs

@@ -0,0 +1,21 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.HDHR.Queries
+{
+    public class GetHDHRTunerCountHandler : IRequestHandler<GetHDHRTunerCount, int>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public GetHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<int> Handle(GetHDHRTunerCount request, CancellationToken cancellationToken) =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.HDHRTunerCount)
+                .Map(result => result.IfNone(2));
+    }
+}

ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Application
+{
+    public interface IJellyfinBackgroundServiceRequest
+    {
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record DisconnectJellyfin : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class DisconnectJellyfinHandler : MediatR.IRequestHandler<DisconnectJellyfin, Either<BaseError, Unit>>
+    {
+        private readonly IEntityLocker _entityLocker;
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public DisconnectJellyfinHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IJellyfinSecretStore jellyfinSecretStore,
+            IEntityLocker entityLocker,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _jellyfinSecretStore = jellyfinSecretStore;
+            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DisconnectJellyfin request,
+            CancellationToken cancellationToken)
+        {
+            List<int> ids = await _mediaSourceRepository.DeleteAllJellyfin();
+            await _searchIndex.RemoveItems(ids);
+            await _jellyfinSecretStore.DeleteAll();
+            _entityLocker.UnlockJellyfin();
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record SaveJellyfinSecrets(JellyfinSecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class SaveJellyfinSecretsHandler : MediatR.IRequestHandler<SaveJellyfinSecrets, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
+        private readonly IJellyfinApiClient _jellyfinApiClient;
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SaveJellyfinSecretsHandler(
+            IJellyfinSecretStore jellyfinSecretStore,
+            IJellyfinApiClient jellyfinApiClient,
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
+        {
+            _jellyfinSecretStore = jellyfinSecretStore;
+            _jellyfinApiClient = jellyfinApiClient;
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(SaveJellyfinSecrets request, CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(PerformSave)
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Validation<BaseError, Parameters>> Validate(SaveJellyfinSecrets request)
+        {
+            Either<BaseError, JellyfinServerInformation> maybeServerInformation = await _jellyfinApiClient
+                .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+
+            return maybeServerInformation.Match(
+                info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
+                error => error);
+        }
+
+        private async Task<Unit> PerformSave(Parameters parameters)
+        {
+            await _jellyfinSecretStore.SaveSecrets(parameters.Secrets);
+            await _mediaSourceRepository.UpsertJellyfin(
+                parameters.Secrets.Address,
+                parameters.ServerInformation.ServerName,
+                parameters.ServerInformation.OperatingSystem);
+            await _channel.WriteAsync(new SynchronizeJellyfinMediaSources());
+
+            return Unit.Default;
+        }
+
+        private record Parameters(JellyfinSecrets Secrets, JellyfinServerInformation ServerInformation);
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record SynchronizeJellyfinAdminUserId(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+        IJellyfinBackgroundServiceRequest;
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs

@@ -0,0 +1,112 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class
+        SynchronizeJellyfinAdminUserIdHandler : MediatR.IRequestHandler<SynchronizeJellyfinAdminUserId,
+            Either<BaseError, Unit>>
+    {
+        private readonly IJellyfinApiClient _jellyfinApiClient;
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+        private readonly ILogger<SynchronizeJellyfinAdminUserIdHandler> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
+
+        public SynchronizeJellyfinAdminUserIdHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository,
+            IJellyfinSecretStore jellyfinSecretStore,
+            IJellyfinApiClient jellyfinApiClient,
+            ILogger<SynchronizeJellyfinAdminUserIdHandler> logger)
+        {
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
+            _jellyfinSecretStore = jellyfinSecretStore;
+            _jellyfinApiClient = jellyfinApiClient;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            SynchronizeJellyfinAdminUserId request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .Map(v => v.ToEither<ConnectionParameters>())
+                .BindT(PerformSync);
+
+        private async Task<Either<BaseError, Unit>> PerformSync(ConnectionParameters parameters)
+        {
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", out string _))
+            {
+                return Unit.Default;
+            }
+
+            Either<BaseError, string> maybeUserId = await _jellyfinApiClient.GetAdminUserId(
+                parameters.ActiveConnection.Address,
+                parameters.ApiKey);
+
+            return await maybeUserId.Match(
+                userId =>
+                {
+                    _logger.LogDebug("Jellyfin admin user id is {UserId}", userId);
+                    _memoryCache.Set($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", userId);
+                    return Task.FromResult<Either<BaseError, Unit>>(Unit.Default);
+                },
+                async error =>
+                {
+                    // clear api key if unable to sync with jellyfin
+                    if (error.Value.Contains("Unauthorized"))
+                    {
+                        await _jellyfinSecretStore.SaveSecrets(
+                            new JellyfinSecrets { Address = parameters.ActiveConnection.Address, ApiKey = null });
+                    }
+
+                    return Left<BaseError, Unit>(error);
+                });
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinAdminUserId request) =>
+            MediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
+            SynchronizeJellyfinAdminUserId request) =>
+            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+                .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Jellyfin media source requires an api key");
+        }
+
+        private record ConnectionParameters(
+            JellyfinMediaSource JellyfinMediaSource,
+            JellyfinConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record SynchronizeJellyfinLibraries(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+        IJellyfinBackgroundServiceRequest;
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs

@@ -0,0 +1,111 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class
+        SynchronizeJellyfinLibrariesHandler : MediatR.IRequestHandler<SynchronizeJellyfinLibraries,
+            Either<BaseError, Unit>>
+
+    {
+        private readonly IJellyfinApiClient _jellyfinApiClient;
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+        private readonly ILogger<SynchronizeJellyfinLibrariesHandler> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeJellyfinLibrariesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IJellyfinSecretStore jellyfinSecretStore,
+            IJellyfinApiClient jellyfinApiClient,
+            ILogger<SynchronizeJellyfinLibrariesHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _jellyfinSecretStore = jellyfinSecretStore;
+            _jellyfinApiClient = jellyfinApiClient;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            SynchronizeJellyfinLibraries request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(SynchronizeLibraries)
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinLibraries request) =>
+            MediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
+            SynchronizeJellyfinLibraries request) =>
+            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+                .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Jellyfin media source requires an api key");
+        }
+
+        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+        {
+            Either<BaseError, List<JellyfinLibrary>> maybeLibraries = await _jellyfinApiClient.GetLibraries(
+                connectionParameters.ActiveConnection.Address,
+                connectionParameters.ApiKey);
+
+            await maybeLibraries.Match(
+                libraries =>
+                {
+                    var existing = connectionParameters.JellyfinMediaSource.Libraries.OfType<JellyfinLibrary>()
+                        .ToList();
+                    var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
+                    var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
+                    return _mediaSourceRepository.UpdateLibraries(
+                        connectionParameters.JellyfinMediaSource.Id,
+                        toAdd,
+                        toRemove);
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Unable to synchronize libraries from jellyfin server {JellyfinServer}: {Error}",
+                        connectionParameters.JellyfinMediaSource.ServerName,
+                        error.Value);
+
+                    return Task.CompletedTask;
+                });
+
+            return Unit.Default;
+        }
+
+        private record ConnectionParameters(
+            JellyfinMediaSource JellyfinMediaSource,
+            JellyfinConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs

@@ -0,0 +1,23 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public interface ISynchronizeJellyfinLibraryById : IRequest<Either<BaseError, string>>,
+        IJellyfinBackgroundServiceRequest
+    {
+        int JellyfinLibraryId { get; }
+        bool ForceScan { get; }
+    }
+
+    public record SynchronizeJellyfinLibraryByIdIfNeeded(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
+    {
+        public bool ForceScan => false;
+    }
+
+    public record ForceSynchronizeJellyfinLibraryById(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
+    {
+        public bool ForceScan => true;
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs

@@ -0,0 +1,172 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class SynchronizeJellyfinLibraryByIdHandler :
+        IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
+        IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IJellyfinMovieLibraryScanner _jellyfinMovieLibraryScanner;
+
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+        private readonly IJellyfinTelevisionLibraryScanner _jellyfinTelevisionLibraryScanner;
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ILogger<SynchronizeJellyfinLibraryByIdHandler> _logger;
+
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeJellyfinLibraryByIdHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IJellyfinSecretStore jellyfinSecretStore,
+            IJellyfinMovieLibraryScanner jellyfinMovieLibraryScanner,
+            IJellyfinTelevisionLibraryScanner jellyfinTelevisionLibraryScanner,
+            ILibraryRepository libraryRepository,
+            IEntityLocker entityLocker,
+            IConfigElementRepository configElementRepository,
+            ILogger<SynchronizeJellyfinLibraryByIdHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _jellyfinSecretStore = jellyfinSecretStore;
+            _jellyfinMovieLibraryScanner = jellyfinMovieLibraryScanner;
+            _jellyfinTelevisionLibraryScanner = jellyfinTelevisionLibraryScanner;
+            _libraryRepository = libraryRepository;
+            _entityLocker = entityLocker;
+            _configElementRepository = configElementRepository;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, string>> Handle(
+            ForceSynchronizeJellyfinLibraryById request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        public Task<Either<BaseError, string>> Handle(
+            SynchronizeJellyfinLibraryByIdIfNeeded request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        private Task<Either<BaseError, string>>
+            Handle(ISynchronizeJellyfinLibraryById request) =>
+            Validate(request)
+                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> Synchronize(RequestParameters parameters)
+        {
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            if (parameters.ForceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
+            {
+                switch (parameters.Library.MediaKind)
+                {
+                    case LibraryMediaKind.Movies:
+                        await _jellyfinMovieLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                    case LibraryMediaKind.Shows:
+                        await _jellyfinTelevisionLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                }
+
+                parameters.Library.LastScan = DateTime.UtcNow;
+                await _libraryRepository.UpdateLastScan(parameters.Library);
+            }
+            else
+            {
+                _logger.LogDebug(
+                    "Skipping unforced scan of jellyfin media library {Name}",
+                    parameters.Library.Name);
+            }
+
+            _entityLocker.UnlockLibrary(parameters.Library.Id);
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, RequestParameters>> Validate(
+            ISynchronizeJellyfinLibraryById request) =>
+            (await ValidateConnection(request), await JellyfinLibraryMustExist(request), await ValidateFFprobePath())
+            .Apply(
+                (connectionParameters, jellyfinLibrary, ffprobePath) => new RequestParameters(
+                    connectionParameters,
+                    jellyfinLibrary,
+                    request.ForceScan,
+                    ffprobePath
+                ));
+
+        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+            ISynchronizeJellyfinLibraryById request) =>
+            JellyfinMediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
+            ISynchronizeJellyfinLibraryById request) =>
+            _mediaSourceRepository.GetJellyfinByLibraryId(request.JellyfinLibraryId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Jellyfin media source for library {request.JellyfinLibraryId} does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Jellyfin media source requires an api key");
+        }
+
+        private Task<Validation<BaseError, JellyfinLibrary>> JellyfinLibraryMustExist(
+            ISynchronizeJellyfinLibraryById request) =>
+            _mediaSourceRepository.GetJellyfinLibrary(request.JellyfinLibraryId)
+                .Map(v => v.ToValidation<BaseError>($"Jellyfin library {request.JellyfinLibraryId} does not exist."));
+
+        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(
+            ConnectionParameters ConnectionParameters,
+            JellyfinLibrary Library,
+            bool ForceScan,
+            string FFprobePath);
+
+        private record ConnectionParameters(
+            JellyfinMediaSource JellyfinMediaSource,
+            JellyfinConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record SynchronizeJellyfinMediaSources : IRequest<Either<BaseError, List<JellyfinMediaSource>>>,
+        IJellyfinBackgroundServiceRequest;
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class SynchronizeJellyfinMediaSourcesHandler : IRequestHandler<SynchronizeJellyfinMediaSources,
+        Either<BaseError, List<JellyfinMediaSource>>>
+    {
+        private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeJellyfinMediaSourcesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, List<JellyfinMediaSource>>> Handle(
+            SynchronizeJellyfinMediaSources request,
+            CancellationToken cancellationToken)
+        {
+            List<JellyfinMediaSource> mediaSources = await _mediaSourceRepository.GetAllJellyfin();
+            foreach (JellyfinMediaSource mediaSource in mediaSources)
+            {
+                await _channel.WriteAsync(new SynchronizeJellyfinAdminUserId(mediaSource.Id), cancellationToken);
+                await _channel.WriteAsync(new SynchronizeJellyfinLibraries(mediaSource.Id), cancellationToken);
+            }
+
+            return mediaSources;
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record UpdateJellyfinLibraryPreferences
+        (List<JellyfinLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record JellyfinLibraryPreference(int Id, bool ShouldSyncItems);
+}

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class
+        UpdateJellyfinLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateJellyfinLibraryPreferences,
+            Either<BaseError, Unit>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public UpdateJellyfinLibraryPreferencesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            UpdateJellyfinLibraryPreferences request,
+            CancellationToken cancellationToken)
+        {
+            var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+            List<int> ids = await _mediaSourceRepository.DisableJellyfinLibrarySync(toDisable);
+            await _searchIndex.RemoveItems(ids);
+
+            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
+            await _mediaSourceRepository.EnableJellyfinLibrarySync(toEnable);
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public record UpdateJellyfinPathReplacements(
+        int JellyfinMediaSourceId,
+        List<JellyfinPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record JellyfinPathReplacementItem(int Id, string JellyfinPath, string LocalPath);
+}

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Jellyfin.Commands
+{
+    public class UpdateJellyfinPathReplacementsHandler : MediatR.IRequestHandler<UpdateJellyfinPathReplacements,
+        Either<BaseError, Unit>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public UpdateJellyfinPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateJellyfinPathReplacements request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(pms => MergePathReplacements(request, pms))
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Unit> MergePathReplacements(
+            UpdateJellyfinPathReplacements request,
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            jellyfinMediaSource.PathReplacements ??= new List<JellyfinPathReplacement>();
+
+            var incoming = request.PathReplacements.Map(Project).ToList();
+
+            var toAdd = incoming.Filter(r => r.Id < 1).ToList();
+            var toRemove = jellyfinMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
+            var toUpdate = incoming.Except(toAdd).ToList();
+
+            return _mediaSourceRepository.UpdatePathReplacements(jellyfinMediaSource.Id, toAdd, toUpdate, toRemove);
+        }
+
+        private static JellyfinPathReplacement Project(JellyfinPathReplacementItem vm) =>
+            new() { Id = vm.Id, JellyfinPath = vm.JellyfinPath, LocalPath = vm.LocalPath };
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> Validate(UpdateJellyfinPathReplacements request) =>
+            JellyfinMediaSourceMustExist(request);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
+            UpdateJellyfinPathReplacements request) =>
+            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Jellyfin media source {request.JellyfinMediaSourceId} does not exist."));
+    }
+}

ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Jellyfin
+{
+    public record JellyfinLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
+        : LibraryViewModel("Jellyfin", Id, Name, MediaKind);
+}

ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Application.MediaSources;
+
+namespace ErsatzTV.Application.Jellyfin
+{
+    public record JellyfinMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
+}

ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Jellyfin
+{
+    public record JellyfinPathReplacementViewModel(int Id, string JellyfinPath, string LocalPath);
+}

ErsatzTV.Application/Jellyfin/Mapper.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Jellyfin
+{
+    internal static class Mapper
+    {
+        internal static JellyfinMediaSourceViewModel ProjectToViewModel(JellyfinMediaSource jellyfinMediaSource) =>
+            new(
+                jellyfinMediaSource.Id,
+                jellyfinMediaSource.ServerName,
+                jellyfinMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
+
+        internal static JellyfinLibraryViewModel ProjectToViewModel(JellyfinLibrary library) =>
+            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+
+        internal static JellyfinPathReplacementViewModel ProjectToViewModel(JellyfinPathReplacement pathReplacement) =>
+            new(pathReplacement.Id, pathReplacement.JellyfinPath, pathReplacement.LocalPath);
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs

@@ -0,0 +1,26 @@
+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.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class
+        GetAllJellyfinMediaSourcesHandler : IRequestHandler<GetAllJellyfinMediaSources,
+            List<JellyfinMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetAllJellyfinMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinMediaSourceViewModel>> Handle(
+            GetAllJellyfinMediaSources request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetAllJellyfin().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinLibrariesBySourceId(int JellyfinMediaSourceId) : IRequest<List<JellyfinLibraryViewModel>>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs

@@ -0,0 +1,27 @@
+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.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class
+        GetJellyfinLibrariesBySourceIdHandler : IRequestHandler<GetJellyfinLibrariesBySourceId,
+            List<JellyfinLibraryViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetJellyfinLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinLibraryViewModel>> Handle(
+            GetJellyfinLibrariesBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetJellyfinLibraries(request.JellyfinMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs

@@ -0,0 +1,8 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinMediaSourceById
+        (int JellyfinMediaSourceId) : IRequest<Option<JellyfinMediaSourceViewModel>>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs

@@ -0,0 +1,24 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class
+        GetJellyfinMediaSourceByIdHandler : IRequestHandler<GetJellyfinMediaSourceById,
+            Option<JellyfinMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetJellyfinMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<Option<JellyfinMediaSourceViewModel>> Handle(
+            GetJellyfinMediaSourceById request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinPathReplacementsBySourceId
+        (int JellyfinMediaSourceId) : IRequest<List<JellyfinPathReplacementViewModel>>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+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.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class GetJellyfinPathReplacementsBySourceIdHandler : IRequestHandler<GetJellyfinPathReplacementsBySourceId,
+        List<JellyfinPathReplacementViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetJellyfinPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinPathReplacementViewModel>> Handle(
+            GetJellyfinPathReplacementsBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetJellyfinPathReplacements(request.JellyfinMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Jellyfin;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinSecrets : IRequest<JellyfinSecrets>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Jellyfin;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class GetJellyfinSecretsHandler : IRequestHandler<GetJellyfinSecrets, JellyfinSecrets>
+    {
+        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+
+        public GetJellyfinSecretsHandler(IJellyfinSecretStore jellyfinSecretStore) =>
+            _jellyfinSecretStore = jellyfinSecretStore;
+
+        public Task<JellyfinSecrets> Handle(GetJellyfinSecrets request, CancellationToken cancellationToken) =>
+            _jellyfinSecretStore.ReadSecrets();
+    }
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

@@ -1,8 +1,10 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using LanguageExt;
 
 namespace ErsatzTV.Application.Libraries.Commands
@@ -11,9 +13,13 @@ namespace ErsatzTV.Application.Libraries.Commands
         DeleteLocalLibraryPathHandler : MediatR.IRequestHandler<DeleteLocalLibraryPath, Either<BaseError, Unit>>
     {
         private readonly ILibraryRepository _libraryRepository;
+        private readonly ISearchIndex _searchIndex;
 
-        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository, ISearchIndex searchIndex)
+        {
             _libraryRepository = libraryRepository;
+            _searchIndex = searchIndex;
+        }
 
         public Task<Either<BaseError, Unit>> Handle(
             DeleteLocalLibraryPath request,
@@ -22,8 +28,13 @@ namespace ErsatzTV.Application.Libraries.Commands
                 .MapT(DoDeletion)
                 .Bind(t => t.ToEitherAsync());
 
-        private Task<Unit> DoDeletion(LibraryPath libraryPath) =>
-            _libraryRepository.DeleteLocalPath(libraryPath.Id).ToUnit();
+        private async Task<Unit> DoDeletion(LibraryPath libraryPath)
+        {
+            List<int> ids = await _libraryRepository.GetMediaIdsByLocalPath(libraryPath.Id);
+            await _searchIndex.RemoveItems(ids);
+            await _libraryRepository.DeleteLocalPath(libraryPath.Id);
+            return Unit.Default;
+        }
 
         private async Task<Validation<BaseError, LibraryPath>> MediaSourceMustExist(DeleteLocalLibraryPath request) =>
             (await _libraryRepository.GetPath(request.LocalLibraryPathId))

ErsatzTV.Application/Libraries/Mapper.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Jellyfin;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Libraries
@@ -10,6 +11,7 @@ namespace ErsatzTV.Application.Libraries
             {
                 LocalLibrary l => ProjectToViewModel(l),
                 PlexLibrary p => new PlexLibraryViewModel(p.Id, p.Name, p.MediaKind),
+                JellyfinLibrary j => new JellyfinLibraryViewModel(j.Id, j.Name, j.MediaKind, j.ShouldSyncItems),
                 _ => throw new ArgumentOutOfRangeException(nameof(library))
             };
 

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -18,13 +18,19 @@ namespace ErsatzTV.Application.Libraries.Queries
 
         public Task<List<LibraryViewModel>> Handle(GetAllLibraries request, CancellationToken cancellationToken) =>
             _libraryRepository.GetAll()
-                .Map(list => list.Filter(ShouldIncludeLibrary).Map(ProjectToViewModel).ToList());
+                .Map(
+                    list => list.Filter(ShouldIncludeLibrary)
+                        .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
+                        .ThenBy(l => l.GetType().Name)
+                        .ThenBy(l => l.MediaKind)
+                        .Map(ProjectToViewModel).ToList());
 
         private static bool ShouldIncludeLibrary(Library library) =>
             library switch
             {
                 LocalLibrary => true,
                 PlexLibrary plex => plex.ShouldSyncItems,
+                JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
                 _ => false
             };
     }

ErsatzTV.Application/Logs/LogEntryViewModel.cs

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

ErsatzTV.Application/Logs/Mapper.cs

@@ -1,16 +1,45 @@
-using ErsatzTV.Core.Domain;
+using System;
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using Newtonsoft.Json.Linq;
+using Serilog.Events;
 
 namespace ErsatzTV.Application.Logs
 {
     internal static class Mapper
     {
-        internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry) =>
-            new(
+        internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry)
+        {
+            string message = logEntry.RenderedMessage;
+            if (!string.IsNullOrWhiteSpace(logEntry.Properties))
+            {
+                foreach (KeyValuePair<string, JToken> property in JObject.Parse(logEntry.Properties))
+                {
+                    var token = $"{{{property.Key}}}";
+                    if (message.Contains(token))
+                    {
+                        message = message.Replace(token, property.Value.ToString());
+                    }
+
+                    var destructureToken = $"{{@{property.Key}}}";
+                    if (message.Contains(destructureToken))
+                    {
+                        message = message.Replace(destructureToken, property.Value.ToString());
+                    }
+                }
+            }
+
+            if (!Enum.TryParse(logEntry.Level, out LogEventLevel level))
+            {
+                level = LogEventLevel.Debug;
+            }
+
+            return new LogEntryViewModel(
                 logEntry.Id,
                 logEntry.Timestamp,
-                logEntry.Level,
+                level,
                 logEntry.Exception,
-                logEntry.RenderedMessage,
-                logEntry.Properties);
+                message);
+        }
     }
 }

ErsatzTV.Application/MediaCards/ActorCardViewModel.cs

@@ -0,0 +1,5 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb) :
+        MediaCardViewModel(Id, Name, Role, Name, Thumb);
+}

ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs

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

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -7,7 +7,9 @@ namespace ErsatzTV.Application.MediaCards
         List<MovieCardViewModel> MovieCards,
         List<TelevisionShowCardViewModel> ShowCards,
         List<TelevisionSeasonCardViewModel> SeasonCards,
-        List<TelevisionEpisodeCardViewModel> EpisodeCards)
+        List<TelevisionEpisodeCardViewModel> EpisodeCards,
+        List<ArtistCardViewModel> ArtistCards,
+        List<MusicVideoCardViewModel> MusicVideoCards)
     {
         public bool UseCustomPlaybackOrder { get; set; }
     }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -1,22 +1,26 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.MediaCards
 {
     internal static class Mapper
     {
-        internal static TelevisionShowCardViewModel ProjectToViewModel(ShowMetadata showMetadata) =>
+        internal static TelevisionShowCardViewModel ProjectToViewModel(
+            ShowMetadata showMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin) =>
             new(
                 showMetadata.ShowId,
                 showMetadata.Title,
                 showMetadata.Year?.ToString(),
                 showMetadata.SortTitle,
-                GetPoster(showMetadata));
+                GetPoster(showMetadata, maybeJellyfin));
 
-        internal static TelevisionSeasonCardViewModel ProjectToViewModel(Season season) =>
+        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+            Season season,
+            Option<JellyfinMediaSource> maybeJellyfin) =>
             new(
                 season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
                 season.Id,
@@ -24,11 +28,12 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(season.SeasonNumber),
                 string.Empty,
                 GetSeasonName(season.SeasonNumber),
-                season.SeasonMetadata.HeadOrNone().Map(GetPoster).IfNone(string.Empty),
+                season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin)).IfNone(string.Empty),
                 season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
 
         internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
-            EpisodeMetadata episodeMetadata) =>
+            EpisodeMetadata episodeMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin) =>
             new(
                 episodeMetadata.EpisodeId,
                 episodeMetadata.ReleaseDate ?? DateTime.MinValue,
@@ -42,49 +47,108 @@ namespace ErsatzTV.Application.MediaCards
                 episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
                     em => em.Plot ?? string.Empty,
                     () => string.Empty),
-                GetThumbnail(episodeMetadata));
+                GetThumbnail(episodeMetadata, maybeJellyfin));
 
-        internal static MovieCardViewModel ProjectToViewModel(MovieMetadata movieMetadata) =>
+        internal static MovieCardViewModel ProjectToViewModel(
+            MovieMetadata movieMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin) =>
             new(
                 movieMetadata.MovieId,
                 movieMetadata.Title,
                 movieMetadata.Year?.ToString(),
                 movieMetadata.SortTitle,
-                GetPoster(movieMetadata));
+                GetPoster(movieMetadata, maybeJellyfin));
+
+        internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
+            new(
+                musicVideoMetadata.MusicVideoId,
+                musicVideoMetadata.Title,
+                musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
+                musicVideoMetadata.SortTitle,
+                musicVideoMetadata.Plot,
+                GetThumbnail(musicVideoMetadata, None));
+
+        internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
+            new(
+                artistMetadata.ArtistId,
+                artistMetadata.Title,
+                artistMetadata.Disambiguation,
+                artistMetadata.SortTitle,
+                GetThumbnail(artistMetadata, None));
 
         internal static CollectionCardResultsViewModel
-            ProjectToViewModel(Collection collection) =>
+            ProjectToViewModel(Collection collection, Option<JellyfinMediaSource> maybeJellyfin) =>
             new(
                 collection.Name,
                 collection.MediaItems.OfType<Movie>().Map(
-                    m => ProjectToViewModel(m.MovieMetadata.Head()) with
+                    m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin) with
                     {
                         CustomIndex = GetCustomIndex(collection, m.Id)
                     }).ToList(),
-                collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList(),
-                collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
-                collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
+                collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin))
+                    .ToList(),
+                collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin)).ToList(),
+                collection.MediaItems.OfType<Episode>()
+                    .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin))
+                    .ToList(),
+                collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
+                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
+        internal static ActorCardViewModel ProjectToViewModel(Actor actor, Option<JellyfinMediaSource> maybeJellyfin)
+        {
+            string artwork = actor.Artwork?.Path ?? string.Empty;
+
+            if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
+            {
+                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+                    .Flatten()
+                    .IfNone("jellyfin://");
+                artwork = artwork.Replace("jellyfin://", address) + "&fillheight=440";
+            }
+
+            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork);
+        }
+
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>
             Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
                 .Map(ci => ci.CustomIndex ?? 0)
                 .IfNone(0);
 
-        internal static SearchCardResultsViewModel ProjectToSearchResults(List<MediaItem> items) =>
-            new(
-                items.OfType<Movie>().Map(m => ProjectToViewModel(m.MovieMetadata.Head())).ToList(),
-                items.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList());
-
         private static string GetSeasonName(int number) =>
             number == 0 ? "Specials" : $"Season {number}";
 
-        private static string GetPoster(Metadata metadata) =>
-            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
+        private static string GetPoster(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin)
+        {
+            string poster = 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))
+            if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
+            {
+                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+                    .Flatten()
+                    .IfNone("jellyfin://");
+                poster = poster.Replace("jellyfin://", address) + "&fillHeight=440";
+            }
+
+            return poster;
+        }
+
+        private static string GetThumbnail(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin)
+        {
+            string thumb = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
                 .Match(a => a.Path, string.Empty);
+
+            if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
+            {
+                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+                    .Flatten()
+                    .IfNone("jellyfin://");
+                thumb = thumb.Replace("jellyfin://", address) +
+                        "&fillHeight=220"; // TODO: this height is optimized for episode
+            }
+
+            return thumb;
+        }
     }
 }

ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

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

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -1,6 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
@@ -12,15 +13,27 @@ namespace ErsatzTV.Application.MediaCards.Queries
         Either<BaseError, CollectionCardResultsViewModel>>
     {
         private readonly IMediaCollectionRepository _collectionRepository;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetCollectionCardsHandler(IMediaCollectionRepository collectionRepository) =>
+        public GetCollectionCardsHandler(
+            IMediaCollectionRepository collectionRepository,
+            IMediaSourceRepository mediaSourceRepository)
+        {
             _collectionRepository = collectionRepository;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
 
-        public Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
+        public async Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
             GetCollectionCards request,
-            CancellationToken cancellationToken) =>
-            _collectionRepository.GetCollectionWithItemsUntracked(request.Id)
+            CancellationToken cancellationToken)
+        {
+            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+                .Map(list => list.HeadOrNone());
+
+            return await _collectionRepository
+                .GetCollectionWithItemsUntracked(request.Id)
                 .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
-                .MapT(ProjectToViewModel);
+                .MapT(c => ProjectToViewModel(c, maybeJellyfin));
+        }
     }
 }

ErsatzTV.Application/MediaCards/Queries/GetMovieCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetMovieCardsHandler.cs

@@ -1,30 +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.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/GetMusicVideoCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.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;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCards.Queries
+{
+    public class GetMusicVideoCardsHandler : IRequestHandler<GetMusicVideoCards, MusicVideoCardResultsViewModel>
+    {
+        private readonly IMusicVideoRepository _musicVideoRepository;
+
+        public GetMusicVideoCardsHandler(IMusicVideoRepository musicVideoRepository) =>
+            _musicVideoRepository = musicVideoRepository;
+
+        public async Task<MusicVideoCardResultsViewModel> Handle(
+            GetMusicVideoCards request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _musicVideoRepository.GetMusicVideoCount(request.ArtistId);
+
+            List<MusicVideoCardViewModel> results = await _musicVideoRepository
+                .GetPagedMusicVideos(request.ArtistId, request.PageNumber, request.PageSize)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new MusicVideoCardResultsViewModel(count, results, None);
+        }
+    }
+}

ErsatzTV.Application/MediaCards/Queries/GetSearchCards.cs

@@ -1,8 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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) =>
-            request.Query.Split(":").Head() switch
-            {
-                "genre" => GenreSearch(request.Query.Replace("genre:", string.Empty)),
-                "tag" => TagSearch(request.Query.Replace("tag:", string.Empty)),
-                _ => TitleSearch(request.Query)
-            };
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> TitleSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByTitle(query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> GenreSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByGenre(query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-
-        private Task<Either<BaseError, SearchCardResultsViewModel>> TagSearch(string query) =>
-            Try(_searchRepository.SearchMediaItemsByTag(query)).Sequence()
-                .Map(ProjectToSearchResults)
-                .Map(t => t.ToEither(ex => BaseError.New($"Failed to search: {ex.Message}")));
-    }
-}

ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
@@ -13,10 +14,16 @@ namespace ErsatzTV.Application.MediaCards.Queries
         GetTelevisionEpisodeCardsHandler : IRequestHandler<GetTelevisionEpisodeCards,
             TelevisionEpisodeCardResultsViewModel>
     {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
-        public GetTelevisionEpisodeCardsHandler(ITelevisionRepository televisionRepository) =>
+        public GetTelevisionEpisodeCardsHandler(
+            ITelevisionRepository televisionRepository,
+            IMediaSourceRepository mediaSourceRepository)
+        {
             _televisionRepository = televisionRepository;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
 
         public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
             GetTelevisionEpisodeCards request,
@@ -24,9 +31,12 @@ namespace ErsatzTV.Application.MediaCards.Queries
         {
             int count = await _televisionRepository.GetEpisodeCount(request.TelevisionSeasonId);
 
+            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+                .Map(list => list.HeadOrNone());
+
             List<TelevisionEpisodeCardViewModel> results = await _televisionRepository
                 .GetPagedEpisodes(request.TelevisionSeasonId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                .Map(list => list.Map(e => ProjectToViewModel(e, maybeJellyfin)).ToList());
 
             return new TelevisionEpisodeCardResultsViewModel(count, results);
         }

ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
@@ -10,13 +11,19 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 namespace ErsatzTV.Application.MediaCards.Queries
 {
     public class
-        GetTelevisionSeasonCardsHandler : IRequestHandler<GetTelevisionSeasonCards, TelevisionSeasonCardResultsViewModel
-        >
+        GetTelevisionSeasonCardsHandler : IRequestHandler<GetTelevisionSeasonCards,
+            TelevisionSeasonCardResultsViewModel>
     {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
-        public GetTelevisionSeasonCardsHandler(ITelevisionRepository televisionRepository) =>
+        public GetTelevisionSeasonCardsHandler(
+            ITelevisionRepository televisionRepository,
+            IMediaSourceRepository mediaSourceRepository)
+        {
             _televisionRepository = televisionRepository;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
 
         public async Task<TelevisionSeasonCardResultsViewModel> Handle(
             GetTelevisionSeasonCards request,
@@ -24,9 +31,12 @@ namespace ErsatzTV.Application.MediaCards.Queries
         {
             int count = await _televisionRepository.GetSeasonCount(request.TelevisionShowId);
 
+            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+                .Map(list => list.HeadOrNone());
+
             List<TelevisionSeasonCardViewModel> results = await _televisionRepository
                 .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin)).ToList());
 
             return new TelevisionSeasonCardResultsViewModel(count, results);
         }

ErsatzTV.Application/MediaCards/Queries/GetTelevisionShowCards.cs

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

ErsatzTV.Application/MediaCards/Queries/GetTelevisionShowCardsHandler.cs

@@ -1,33 +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.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/TelevisionShowCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.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
+        AddArtistToCollectionHandler : MediatR.IRequestHandler<AddArtistToCollection, Either<BaseError, Unit>>
+    {
+        private readonly IArtistRepository _artistRepository;
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddArtistToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IArtistRepository artistRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _artistRepository = artistRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddArtistToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddArtistRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddArtistRequest(AddArtistToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.ArtistId))
+            {
+                // 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(AddArtistToCollection request) =>
+            (await CollectionMustExist(request), await ValidateArtist(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddArtistToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateArtist(AddArtistToCollection request) =>
+            LoadArtist(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Music video does not exist"));
+
+        private Task<Option<Artist>> LoadArtist(AddArtistToCollection request) =>
+            _artistRepository.GetArtist(request.ArtistId);
+    }
+}