update changelog for release 59 [no ci]

* properly disable transcoding in MPEG-TS mode

* update changelog

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: nuget
+    directory: "/"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove

.github/workflows/release.yml

@@ -11,6 +11,9 @@ jobs:
           - os: ubuntu-latest
             kind: linux
             target: linux-x64
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
           - os: windows-latest
             kind: windows
             target: win-x64
@@ -39,24 +42,22 @@ jobs:
           # Define some variables for things we need
           tag=$(git describe --tags --abbrev=0)
           release_name="ErsatzTV-$tag-${{ matrix.target }}"
-          #release_name_cli="ErsatzTV.CommandLine-$tag-${{ matrix.target }}"
 
           # Build everything
           dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:PublishSingleFile=true --self-contained true
-          #dotnet publish ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name_cli" /property:InformationalVersion="${tag:1}-${{ matrix.target }}"
 
           # Pack files
           if [ "${{ matrix.target }}" == "win-x64" ]; then
             7z a -tzip "${release_name}.zip" "./${release_name}/*"
-            #7z a -tzip "${release_name_cli}.zip" "./${release_name_cli}/*"
+          elif [ "${{ matrix.target }}" == "linux-arm" ]; then
+            cp lib/linux-arm/* "$release_name/"
+            tar czvf "${release_name}.tar.gz" "$release_name"
           else
             tar czvf "${release_name}.tar.gz" "$release_name"
-            #tar czvf "${release_name_cli}.tar.gz" "$release_name_cli"
           fi
 
           # Delete output directory
           rm -r "$release_name"
-          #rm -r "$release_name_cli"
 
       - name: Publish
         uses: softprops/action-gh-release@v1

CHANGELOG.md

@@ -5,6 +5,152 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [0.0.59-alpha] - 2021-09-18
+### Added
+- Add `Health Checks` table to home page to identify and surface common misconfigurations
+  - `FFmpeg Version` checks `ffmpeg` and `ffprobe` versions
+  - `FFmpeg Reports` checks whether ffmpeg troubleshooting reports are enabled since they can use a lot of disk space over time
+  - `Hardware Acceleration` checks whether channels that transcode are using acceleration methods that ffmpeg claims to support
+  - `Movie Metadata` checks whether all movies have metadata (fallback metadata counts as metadata)
+  - `Episode Metadata` checks whether all episodes have metadata (fallback metadata counts as metadata)
+  - `Zero Duration` checks whether all movies and episodes have a valid (non-zero) duration
+  - `VAAPI Driver` checks whether a vaapi driver preference is configured when using the vaapi docker image
+- Add setting to each playout to schedule an automatic daily rebuild
+  - This is useful if the playout uses a smart collection with `released_onthisday`
+
+### Fixed
+- Fix docker vaapi support for newer Intel platforms (Gen 8+)
+  - This includes a new setting to force a particular vaapi driver (`iHD` or `i965`), as some Gen 8 or 9 hardware that is supported by both drivers will perform better with one or the other
+- Fix scanning and indexing local movies and episodes without NFO metadata
+- Fix displaying seasons for shows with no year (in metadata or in folder name)
+- Fix "direct play" in MPEG-TS mode (copy audio and video stream when `Transcode` is unchecked)
+
+## [0.0.58-alpha] - 2021-09-15
+### Added
+- Add `released_notinthelast` search field for relative release date queries
+  - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
+- Add `released_onthisday` search field for historical queries
+  - Syntax is `released_onthisday:1` and will search for items released on this month number and day number in prior years
+- Add tooltip explaining `Keep Multi-Part Episodes Together`
+
+### Fixed
+- Properly display watermark when no other video filters (like scaling or padding) are required
+- Fix building some playouts in timezones with positive offsets (like UTC+2)
+- Fix `Shuffle In Order` so all collections/shows start from the earliest episode
+  - You may need to rebuild playouts to see this fixed behavior more quickly
+
+## [0.0.57-alpha] - 2021-09-10
+### Added
+- Add `released_inthelast` search field for relative release date queries
+  - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
+- Allow adding smart collections to multi collections
+
+### Fixed
+- Fix loading artwork in Kodi
+  - Use fake image extension (`.jpg`) for artwork in M3U and XMLTV since Kodi detects MIME type from URL
+  - Enable HEAD requests for IPTV image paths since Kodi requires those
+
+## [0.0.56-alpha] - 2021-09-10
+### Added
+- Add Smart Collections
+  - Smart Collections use search queries and can be created from the search result page
+  - Smart Collections are re-evaluated every time playouts are extended or rebuilt to automatically include newly-matching items
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+- Allow `Shuffle In Order` with Collections and Smart Collections
+  - Episodes will be grouped by show, and music videos will be grouped by artist
+  - All movies will be a single group (multi-collections are probably better if `Shuffle In Order` is desired for movies)
+  - All groups will be be ordered chronologically (custom ordering is only supported in multi-collections)
+
+### Fixed
+- Generate XMLTV that validates successfully
+  - Properly order elements
+  - Omit channels with no programmes
+  - Properly identify channels using the format number.etv like `15.etv`
+- Fix building playouts when multi-part episode grouping is enabled and episodes are missing metadata
+- Fix incorrect total items count in `Multi Collections` table
+
+## [0.0.55-alpha] - 2021-09-03
+### Fixed
+- Fix all local library scanners to ignore dot underscore files (`._`)
+
+## [0.0.54-alpha] - 2021-08-21
+### Added
+- Add `Shuffle In Order` playback order for multi-collections.
+  - This is useful for randomizing multiple collections/shows on a single channel, while each collection maintains proper ordering (custom or chronological)
+
+### Fixed
+- Fix bug parsing ffprobe output in cultures where `.` is a group/thousands separator
+  - This bug likely prevented ETV from scheduling correctly or working at all in those cultures
+  - After installing a version with this fix, affected content will need to be removed from ETV and re-added
+
+## [0.0.53-alpha] - 2021-08-01
+### Fixed
+- Fix error message displayed after building empty playout
+- Fix Emby and Jellyfin links
+
+### Changed
+- Always proxy Jellyfin and Emby artwork; this fixes artwork in some networking scenarios
+
+## [0.0.52-alpha] - 2021-07-22
+### Added
+- Add multiple local libraries to better organize your media
+- Add `Move Library Path` function to support reorganizing existing local libraries
+
+### Fixed
+- Fix bug preventing playouts from rebuilding after an empty collection is encountered within a multi-collection
+
+## [0.0.51-alpha] - 2021-07-18
+### Added
+- Add `Multi Collection` to support shuffling multiple collections within a single schedule item
+  - Collections within a multi collection are optionally grouped together and ordered when scheduling; this can be useful for franchises
+- Add `Playout Days To Build` setting to control how many days of playout data/program guide data should be built into the future
+
+### Changed
+- Move `Playback Order` from schedule to schedule items
+  - This allows different schedule items to have different playback orders within a single schedule
+
+### Fixed
+- Fix release notes on home page with `-alpha` suffix
+- Fix linux-arm release by including SQLite interop artifacts
+- Fix issue where cached Plex credentials may become invalid when multiple servers are used
+
+## [0.0.50-alpha] - 2021-07-13
+### Added
+- Add Linux ARM release artifacts which can be used on Raspberry Pi devices
+
+### Fixed
+- Fix bug preventing ingestion of local movies with fallback metadata (without NFO files)
+- Fix extra spaces in titles of local movies with fallback metadata (without NFO files)
+
+## [0.0.49-prealpha] - 2021-07-11
+### Added
+- Include audio language metadata in all streaming modes
+- Add special zero-count case to `Multiple` playout mode
+  - This configuration will automatically maintain the multiple count so that it is equal to the number of items in the collection
+  - This configuration should be used if you want to play every item in a collection exactly once before advancing
+
+### Changed
+- Use case-insensitive sorting for collections page and `Add to Collection` dialog
+- Use case-insensitive sorting for all collection lists in schedule items editor
+- Use natural sorting for schedules page and `Add to Schedule` dialog
+
+### Fixed
+- Fix flooding schedule items that have a fixed start time
+
+## [0.0.48-prealpha] - 2021-06-22
+### Added
+- Store pixel format with media statistics; this is needed to support normalization of 10-bit media items
+  - This requires re-ingesting statistics for all media items the first time this version is launched
+
+### Changed
+- Use ffprobe to retrieve statistics for Plex media items (Local, Emby and Jellyfin libraries already use ffprobe)
+
+### Fixed
+- Fix playback of transcoded 10-bit media items (pixel format `yuv420p10le`) on Nvidia hardware
+- Emby and Jellyfin scanners now respect library refresh interval setting
+- Fix adding new seasons to existing Emby and Jellyfin shows
+- Fix adding new episodes to existing Emby and Jellyfin seasons
+
 ## [0.0.47-prealpha] - 2021-06-15
 ### Added
 - Add warning during playout rebuild when schedule has been emptied
@@ -468,7 +614,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.47-prealpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.59-alpha...HEAD
+[0.0.59-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.58-alpha...v0.0.59-alpha
+[0.0.58-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.57-alpha...v0.0.58-alpha
+[0.0.57-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.56-alpha...v0.0.57-alpha
+[0.0.56-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.55-alpha...v0.0.56-alpha
+[0.0.55-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.54-alpha...v0.0.55-alpha
+[0.0.54-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.53-alpha...v0.0.54-alpha
+[0.0.53-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.52-alpha...v0.0.53-alpha
+[0.0.52-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.51-alpha...v0.0.52-alpha
+[0.0.51-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.50-alpha...v0.0.51-alpha
+[0.0.50-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.49-prealpha...v0.0.50-alpha
+[0.0.49-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.48-prealpha...v0.0.49-prealpha
+[0.0.48-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.47-prealpha...v0.0.48-prealpha
 [0.0.47-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.46-prealpha...v0.0.47-prealpha
 [0.0.46-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.45-prealpha...v0.0.46-prealpha
 [0.0.45-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.44-prealpha...v0.0.45-prealpha

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Configuration.Commands
+{
+    public class
+        UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+        public UpdatePlayoutDaysToBuildHandler(
+            IConfigElementRepository configElementRepository,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ChannelWriter<IBackgroundServiceRequest> workerChannel)
+        {
+            _configElementRepository = configElementRepository;
+            _dbContextFactory = dbContextFactory;
+            _workerChannel = workerChannel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            UpdatePlayoutDaysToBuild request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Unit> validation = await Validate(request);
+            return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.DaysToBuild));
+        }
+
+        private async Task<Unit> ApplyUpdate(TvContext dbContext, int daysToBuild)
+        {
+            await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, daysToBuild);
+            
+            // build all playouts to proper number of days
+            List<Playout> playouts = await dbContext.Playouts
+                .Include(p => p.Channel)
+                .ToListAsync();
+            foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
+            {
+                await _workerChannel.WriteAsync(new BuildPlayout(playoutId));
+            }
+            
+            return Unit.Default;
+        }
+
+        private static Task<Validation<BaseError, Unit>> Validate(UpdatePlayoutDaysToBuild request) =>
+            Optional(request.DaysToBuild)
+                .Filter(days => days > 0)
+                .Map(_ => Unit.Default)
+                .ToValidation<BaseError>("Days to build must be greater than zero")
+                .AsTask();
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.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 GetPlayoutDaysToBuildHandler : IRequestHandler<GetPlayoutDaysToBuild, int>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+
+        public GetPlayoutDaysToBuildHandler(IConfigElementRepository configElementRepository) =>
+            _configElementRepository = configElementRepository;
+
+        public Task<int> Handle(GetPlayoutDaysToBuild request, CancellationToken cancellationToken) =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
+                .Map(result => result.IfNone(2));
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -67,8 +67,9 @@ namespace ErsatzTV.Application.Emby.Commands
 
         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))
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
             {
                 switch (parameters.Library.MediaKind)
                 {
@@ -104,12 +105,14 @@ namespace ErsatzTV.Application.Emby.Commands
 
         private async Task<Validation<BaseError, RequestParameters>> Validate(
             ISynchronizeEmbyLibraryById request) =>
-            (await ValidateConnection(request), await EmbyLibraryMustExist(request), await ValidateFFprobePath())
+            (await ValidateConnection(request), await EmbyLibraryMustExist(request),
+                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
             .Apply(
-                (connectionParameters, embyLibrary, ffprobePath) => new RequestParameters(
+                (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
                     connectionParameters,
                     embyLibrary,
                     request.ForceScan,
+                    libraryRefreshInterval,
                     ffprobePath
                 ));
 
@@ -149,6 +152,11 @@ namespace ErsatzTV.Application.Emby.Commands
             _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
                 .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
 
+        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+                .FilterT(lri => lri > 0)
+                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
         private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
             _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
                 .FilterT(File.Exists)
@@ -160,6 +168,7 @@ namespace ErsatzTV.Application.Emby.Commands
             ConnectionParameters ConnectionParameters,
             EmbyLibrary Library,
             bool ForceScan,
+            int LibraryRefreshInterval,
             string FFprobePath);
 
         private record ConnectionParameters(

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -13,7 +13,7 @@
       </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">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -37,17 +37,17 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.Transcode = update.Transcode;
             p.HardwareAcceleration = update.HardwareAcceleration;
             p.ResolutionId = update.ResolutionId;
-            p.NormalizeVideo = update.NormalizeVideo;
+            p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
             p.VideoCodec = update.VideoCodec;
             p.VideoBitrate = update.VideoBitrate;
             p.VideoBufferSize = update.VideoBufferSize;
             p.AudioCodec = update.AudioCodec;
             p.AudioBitrate = update.AudioBitrate;
             p.AudioBufferSize = update.AudioBufferSize;
-            p.NormalizeLoudness = update.NormalizeLoudness;
+            p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
             p.AudioChannels = update.AudioChannels;
             p.AudioSampleRate = update.AudioSampleRate;
-            p.NormalizeAudio = update.NormalizeAudio;
+            p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
             await dbContext.SaveChangesAsync();
             return new UpdateFFmpegProfileResult(p.Id);
         }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -115,6 +115,10 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
             }
 
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegVaapiDriver,
+                (int)request.Settings.VaapiDriver);
+
             return Unit.Default;
         }
     }

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Application.FFmpegProfiles
+using ErsatzTV.Core.FFmpeg;
+
+namespace ErsatzTV.Application.FFmpegProfiles
 {
     public class FFmpegSettingsViewModel
     {
@@ -8,5 +10,6 @@
         public string PreferredLanguageCode { get; set; }
         public bool SaveReports { get; set; }
         public int? GlobalWatermarkId { get; set; }
+        public VaapiDriver VaapiDriver { get; set; }
     }
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -1,6 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
@@ -28,6 +29,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                 await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
             Option<int> watermark =
                 await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
+            Option<int> vaapiDriver =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegVaapiDriver);
 
             var result = new FFmpegSettingsViewModel
             {
@@ -36,6 +39,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                 DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
                 SaveReports = await saveReports.IfNoneAsync(false),
                 PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
+                VaapiDriver = (VaapiDriver)await vaapiDriver.IfNoneAsync(0)
             };
 
             foreach (int watermarkId in watermark)

ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public record GetAllHealthCheckResults : IRequest<List<HealthCheckResult>>;
+}

ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheckResults, List<HealthCheckResult>>
+    {
+        private readonly IHealthCheckService _healthCheckService;
+
+        public GetAllHealthCheckResultsHandler(IHealthCheckService healthCheckService) =>
+            _healthCheckService = healthCheckService;
+
+        public async Task<List<HealthCheckResult>> Handle(
+            GetAllHealthCheckResults request,
+            CancellationToken cancellationToken)
+        {
+            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
+            return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
+        }
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs

@@ -67,8 +67,9 @@ namespace ErsatzTV.Application.Jellyfin.Commands
 
         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))
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
             {
                 switch (parameters.Library.MediaKind)
                 {
@@ -104,12 +105,14 @@ namespace ErsatzTV.Application.Jellyfin.Commands
 
         private async Task<Validation<BaseError, RequestParameters>> Validate(
             ISynchronizeJellyfinLibraryById request) =>
-            (await ValidateConnection(request), await JellyfinLibraryMustExist(request), await ValidateFFprobePath())
+            (await ValidateConnection(request), await JellyfinLibraryMustExist(request),
+                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
             .Apply(
-                (connectionParameters, jellyfinLibrary, ffprobePath) => new RequestParameters(
+                (connectionParameters, jellyfinLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
                     connectionParameters,
                     jellyfinLibrary,
                     request.ForceScan,
+                    libraryRefreshInterval,
                     ffprobePath
                 ));
 
@@ -149,6 +152,11 @@ namespace ErsatzTV.Application.Jellyfin.Commands
             _mediaSourceRepository.GetJellyfinLibrary(request.JellyfinLibraryId)
                 .Map(v => v.ToValidation<BaseError>($"Jellyfin library {request.JellyfinLibraryId} does not exist."));
 
+        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+                .FilterT(lri => lri > 0)
+                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
         private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
             _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
                 .FilterT(File.Exists)
@@ -160,6 +168,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
             ConnectionParameters ConnectionParameters,
             JellyfinLibrary Library,
             bool ForceScan,
+            int LibraryRefreshInterval,
             string FFprobePath);
 
         private record ConnectionParameters(

ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record CreateLocalLibrary(string Name, LibraryMediaKind MediaKind, List<string> Paths)
+        : ILocalLibraryRequest, IRequest<Either<BaseError, LocalLibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaSources.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Libraries.Mapper;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class CreateLocalLibraryHandler : LocalLibraryHandlerBase,
+        IRequestHandler<CreateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public CreateLocalLibraryHandler(
+            ChannelWriter<IBackgroundServiceRequest> workerChannel,
+            IEntityLocker entityLocker,
+            IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _workerChannel = workerChannel;
+            _entityLocker = entityLocker;
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+            CreateLocalLibrary request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, LocalLibrary> validation = await Validate(dbContext, request);
+            return await validation.Apply(localLibrary => PersistLocalLibrary(dbContext, localLibrary));
+        }
+
+        private async Task<LocalLibraryViewModel> PersistLocalLibrary(
+            TvContext dbContext,
+            LocalLibrary localLibrary)
+        {
+            await dbContext.LocalLibraries.AddAsync(localLibrary);
+            await dbContext.SaveChangesAsync();
+            
+            if (_entityLocker.LockLibrary(localLibrary.Id))
+            {
+                await _workerChannel.WriteAsync(new ForceScanLocalLibrary(localLibrary.Id));
+            }
+
+            return ProjectToViewModel(localLibrary);
+        }
+
+        private static Task<Validation<BaseError, LocalLibrary>> Validate(
+            TvContext dbContext,
+            CreateLocalLibrary request) =>
+            MediaSourceMustExist(dbContext, request)
+                .BindT(localLibrary => NameMustBeValid(request, localLibrary))
+                .BindT(localLibrary => PathsMustBeValid(dbContext, localLibrary));
+
+        private static Task<Validation<BaseError, LocalLibrary>> MediaSourceMustExist(
+            TvContext dbContext,
+            CreateLocalLibrary request) =>
+            dbContext.LocalMediaSources
+                .OrderBy(lms => lms.Id)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(
+                    lms => new LocalLibrary
+                    {
+                        Name = request.Name,
+                        Paths = request.Paths.Map(p => new LibraryPath { Path = p }).ToList(),
+                        MediaKind = request.MediaKind,
+                        MediaSourceId = lms.Id
+                    })
+                .Map(o => o.ToValidation<BaseError>("LocalMediaSource does not exist."));
+    }
+}

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs

@@ -19,8 +19,8 @@ namespace ErsatzTV.Application.Libraries.Commands
     {
         private readonly ILibraryRepository _libraryRepository;
 
-        public CreateLocalLibraryPathHandler(ILibraryRepository mediaSourceRepository) =>
-            _libraryRepository = mediaSourceRepository;
+        public CreateLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
 
         public Task<Either<BaseError, LocalLibraryPathViewModel>> Handle(
             CreateLocalLibraryPath request,
@@ -45,7 +45,6 @@ namespace ErsatzTV.Application.Libraries.Commands
             List<string> allPaths = await _libraryRepository.GetLocalPaths(request.LibraryId)
                 .Map(list => list.Map(c => c.Path).ToList());
 
-
             return Optional(request.Path)
                 .Filter(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
                 .ToValidation<BaseError>("Path must not belong to another library path");

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs

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

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs

@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class DeleteLocalLibraryHandler : LocalLibraryHandlerBase,
+        IRequestHandler<DeleteLocalLibrary, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IDbConnection _dbConnection;
+        private readonly ISearchIndex _searchIndex;
+
+        public DeleteLocalLibraryHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IDbConnection dbConnection,
+            ISearchIndex searchIndex)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteLocalLibrary request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, LocalLibrary> validation =  await LocalLibraryMustExist(dbContext, request);
+            return await validation.Apply(localLibrary => DoDeletion(dbContext, localLibrary));
+        }
+
+        private async Task<Unit> DoDeletion(TvContext dbContext, LocalLibrary localLibrary)
+        {
+            List<int> ids = await _dbConnection.QueryAsync<int>(
+                    @"SELECT MediaItem.Id FROM MediaItem
+                      INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                      WHERE LP.LibraryId = @LibraryId",
+                    new { LibraryId = localLibrary.Id })
+                .Map(result => result.ToList());
+
+            await _searchIndex.RemoveItems(ids);
+            _searchIndex.Commit();
+
+            dbContext.LocalLibraries.Remove(localLibrary);
+            await dbContext.SaveChangesAsync();
+
+            return Unit.Default;
+        }
+
+        private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
+            TvContext dbContext,
+            DeleteLocalLibrary request) =>
+            dbContext.LocalLibraries
+                .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.LocalLibraryId)
+                .Map(o => o.ToValidation<BaseError>($"Local library {request.LocalLibraryId} does not exist."));
+    }
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPath.cs

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

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

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

ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public interface ILocalLibraryRequest
+    {
+        public string Name { get; }
+    }
+}

ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public abstract class LocalLibraryHandlerBase
+    {
+        protected static Task<Validation<BaseError, LocalLibrary>> NameMustBeValid(
+            ILocalLibraryRequest request,
+            LocalLibrary localLibrary) =>
+            request.NotEmpty(c => c.Name)
+                .Bind(_ => request.NotLongerThan(50)(c => c.Name))
+                .Map(_ => localLibrary).AsTask();
+
+        protected static async Task<Validation<BaseError, LocalLibrary>> PathsMustBeValid(
+            TvContext dbContext,
+            LocalLibrary localLibrary,
+            int? existingLibraryId = null)
+        {
+            List<string> allPaths = await dbContext.LocalLibraries
+                .Include(ll => ll.Paths)
+                .Filter(ll => existingLibraryId == null || ll.Id != existingLibraryId)
+                .ToListAsync()
+                .Map(list => list.SelectMany(ll => ll.Paths).Map(lp => lp.Path).ToList());
+
+            return Optional(localLibrary.Paths.Count(folder => allPaths.Any(f => AreSubPaths(f, folder.Path))))
+                .Filter(length => length == 0)
+                .Map(_ => localLibrary)
+                .ToValidation<BaseError>("Path must not belong to another library path");
+        }
+        
+        private static bool AreSubPaths(string path1, string path2)
+        {
+            string one = path1 + Path.DirectorySeparatorChar;
+            string two = path2 + Path.DirectorySeparatorChar;
+            return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
+                   two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record MoveLocalLibraryPath(int LibraryPathId, int TargetLibraryId) : IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs

@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath, Either<BaseError, Unit>>
+    {
+        private readonly ISearchIndex _searchIndex;
+        private readonly ISearchRepository _searchRepository;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IDbConnection _dbConnection;
+        private readonly ILogger<MoveLocalLibraryPathHandler> _logger;
+
+        public MoveLocalLibraryPathHandler(
+            ISearchIndex searchIndex,
+            ISearchRepository searchRepository,
+            IDbContextFactory<TvContext> dbContextFactory,
+            IDbConnection dbConnection,
+            ILogger<MoveLocalLibraryPathHandler> logger)
+        {
+            _searchIndex = searchIndex;
+            _searchRepository = searchRepository;
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            MoveLocalLibraryPath request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => MovePath(dbContext, parameters));
+        }
+
+        private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters)
+        {
+            LibraryPath path = parameters.LibraryPath;
+            LocalLibrary newLibrary = parameters.Library;
+
+            path.LibraryId = newLibrary.Id;
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                List<int> ids = await _dbConnection.QueryAsync<int>(
+                        @"SELECT MediaItem.Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
+                        new { LibraryPathId = path.Id })
+                    .Map(result => result.ToList());
+
+                foreach (int id in ids)
+                {
+                    Option<MediaItem> maybeMediaItem = await _searchRepository.GetItemToIndex(id);
+                    foreach (MediaItem mediaItem in maybeMediaItem)
+                    {
+                        _logger.LogInformation("Moving item at {Path}", await GetPath(mediaItem));
+                        await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { mediaItem });
+                    }
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            MoveLocalLibraryPath request) =>
+            (await LibraryPathMustExist(dbContext, request), await LocalLibraryMustExist(dbContext, request))
+            .Apply((libraryPath, localLibrary) => new Parameters(libraryPath, localLibrary));
+
+        private static Task<Validation<BaseError, LibraryPath>> LibraryPathMustExist(
+            TvContext dbContext,
+            MoveLocalLibraryPath request) =>
+            dbContext.LibraryPaths
+                .Include(lp => lp.Library)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.LibraryPathId)
+                .Map(o => o.ToValidation<BaseError>("LibraryPath does not exist."));
+
+        private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
+            TvContext dbContext,
+            MoveLocalLibraryPath request) =>
+            dbContext.LocalLibraries
+                .Include(ll => ll.Paths)
+                .SelectOneAsync(a => a.Id, a => a.Id == request.TargetLibraryId)
+                .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist"));
+
+        private async Task<string> GetPath(MediaItem mediaItem) =>
+            mediaItem switch
+            {
+                Movie => await _dbConnection.QuerySingleAsync<string>(
+                    @"SELECT Path FROM MediaFile
+                      INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
+                      WHERE MV.MovieId = @Id", new { mediaItem.Id }),
+                Episode => await _dbConnection.QuerySingleAsync<string>(
+                    @"SELECT Path FROM MediaFile
+                      INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
+                      WHERE MV.EpisodeId = @Id", new { mediaItem.Id }),
+                MusicVideo => await _dbConnection.QuerySingleAsync<string>(
+                    @"SELECT Path FROM MediaFile
+                      INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
+                      WHERE MV.MusicVideoId = @Id", new { mediaItem.Id }),
+                _ => null
+            };
+
+        private record Parameters(LibraryPath LibraryPath, LocalLibrary Library);
+    }
+}

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record UpdateLocalLibraryPath(int Id, string Path);
+
+    public record UpdateLocalLibrary(int Id, string Name, List<UpdateLocalLibraryPath> Paths) : ILocalLibraryRequest,
+        IRequest<Either<BaseError, LocalLibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs

@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaSources.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
+        IRequestHandler<UpdateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdateLocalLibraryHandler(
+            ChannelWriter<IBackgroundServiceRequest> workerChannel,
+            IEntityLocker entityLocker,
+            IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _workerChannel = workerChannel;
+            _entityLocker = entityLocker;
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+            UpdateLocalLibrary request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => UpdateLocalLibrary(dbContext, parameters));
+        }
+
+        private async Task<LocalLibraryViewModel> UpdateLocalLibrary(TvContext dbContext, Parameters parameters)
+        {
+            (LocalLibrary existing, LocalLibrary incoming) = parameters;
+            existing.Name = incoming.Name;
+            
+            // toAdd
+            var toAdd = incoming.Paths
+                .Filter(p => existing.Paths.All(ep => NormalizePath(ep.Path) != NormalizePath(p.Path)))
+                .ToList();
+            var toRemove = existing.Paths
+                .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
+                .ToList();
+
+            existing.Paths.RemoveAll(toRemove.Contains);
+            existing.Paths.AddRange(toAdd);
+
+            await dbContext.SaveChangesAsync();
+
+            if (toAdd.Count > 0 || toRemove.Count > 0 && _entityLocker.LockLibrary(existing.Id))
+            {
+                await _workerChannel.WriteAsync(new ForceScanLocalLibrary(existing.Id));
+            }
+
+            return ProjectToViewModel(existing);
+        }
+
+        private static Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            UpdateLocalLibrary request) =>
+            LocalLibraryMustExist(dbContext, request)
+                .BindT(parameters => NameMustBeValid(request, parameters.Incoming).MapT(_ => parameters))
+                .BindT(
+                    parameters => PathsMustBeValid(dbContext, parameters.Incoming, parameters.Existing.Id)
+                        .MapT(_ => parameters));
+
+        private static Task<Validation<BaseError, Parameters>> LocalLibraryMustExist(
+            TvContext dbContext,
+            UpdateLocalLibrary request) =>
+            dbContext.LocalLibraries
+                .Include(ll => ll.Paths)
+                .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.Id)
+                .MapT(
+                    existing =>
+                    {
+                        var incoming = new LocalLibrary
+                        {
+                            Name = request.Name,
+                            Paths = request.Paths.Map(p => new LibraryPath { Id = p.Id, Path = p.Path }).ToList(),
+                            MediaSourceId = existing.Id
+                        };
+
+                        return new Parameters(existing, incoming);
+                    })
+                .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist."));
+
+        private record Parameters(LocalLibrary Existing, LocalLibrary Incoming);
+        
+        private static string NormalizePath(string path)
+        {
+            return Path.GetFullPath(new Uri(path).LocalPath)
+                .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+                .ToUpperInvariant();
+        }
+    }
+}

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs

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

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs

@@ -0,0 +1,25 @@
+using System.Data;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class CountMediaItemsByLibraryHandler : IRequestHandler<CountMediaItemsByLibrary, int>
+    {
+        private readonly IDbConnection _dbConnection;
+
+        public CountMediaItemsByLibraryHandler(IDbConnection dbConnection)
+        {
+            _dbConnection = dbConnection;
+        }
+
+        public Task<int> Handle(CountMediaItemsByLibrary request, CancellationToken cancellationToken) =>
+            _dbConnection.QuerySingleAsync<int>(
+                @"SELECT COUNT(*) FROM MediaItem
+                  INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                  WHERE LP.LibraryId = @LibraryId",
+                new { request.LibraryId });
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs

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

ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class GetAllLocalLibrariesHandler : IRequestHandler<GetAllLocalLibraries, List<LocalLibraryViewModel>>
+    {
+        private readonly ILibraryRepository _libraryRepository;
+
+        public GetAllLocalLibrariesHandler(ILibraryRepository libraryRepository) => _libraryRepository = libraryRepository;
+
+        public Task<List<LocalLibraryViewModel>> Handle(
+            GetAllLocalLibraries request,
+            CancellationToken cancellationToken) =>
+            _libraryRepository.GetAll()
+                .Map(
+                    list => list
+                        .OfType<LocalLibrary>()
+                        .OrderBy(l => l.MediaKind)
+                        .Map(ProjectToViewModel)
+                        .ToList());
+    }
+}

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
@@ -43,7 +44,7 @@ namespace ErsatzTV.Application.MediaCards
             bool isSearchResult) =>
             new(
                 episodeMetadata.EpisodeId,
-                episodeMetadata.ReleaseDate ?? DateTime.MinValue,
+                episodeMetadata.ReleaseDate ?? SystemTime.MinValueUtc,
                 episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
                     m => m.Title ?? string.Empty,
                     () => string.Empty),
@@ -123,12 +124,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                artwork = JellyfinUrl.ForArtwork(maybeJellyfin, artwork)
+                artwork = JellyfinUrl.RelativeProxyForArtwork(artwork)
                     .SetQueryParam("fillHeight", 440);
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                artwork = EmbyUrl.ForArtwork(maybeEmby, artwork)
+                artwork = EmbyUrl.RelativeProxyForArtwork(artwork)
                     .SetQueryParam("maxHeight", 440);
             }
 
@@ -171,12 +172,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
             {
-                poster = JellyfinUrl.ForArtwork(maybeJellyfin, poster)
+                poster = JellyfinUrl.RelativeProxyForArtwork(poster)
                     .SetQueryParam("fillHeight", 440);
             }
             else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
             {
-                poster = EmbyUrl.ForArtwork(maybeEmby, poster)
+                poster = EmbyUrl.RelativeProxyForArtwork(poster)
                     .SetQueryParam("maxHeight", 440);
             }
 
@@ -193,12 +194,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
             {
-                thumb = JellyfinUrl.ForArtwork(maybeJellyfin, thumb)
+                thumb = JellyfinUrl.RelativeProxyForArtwork(thumb)
                     .SetQueryParam("fillHeight", 220);
             }
             else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
             {
-                thumb = EmbyUrl.ForArtwork(maybeEmby, thumb)
+                thumb = EmbyUrl.RelativeProxyForArtwork(thumb)
                     .SetQueryParam("maxHeight", 220);
             }
 

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs

@@ -73,7 +73,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddArtistToCollection request) =>
             dbContext.Artists
                 .SelectOneAsync(a => a.Id, a => a.Id == request.ArtistId)
-                .Map(o => o.ToValidation<BaseError>("Music video does not exist"));
+                .Map(o => o.ToValidation<BaseError>("Artist does not exist"));
 
         private record Parameters(Collection Collection, Artist Artist);
     }

ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollection.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record CreateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+
+    public record CreateMultiCollection
+        (string Name, List<CreateMultiCollectionItem> Items) : IRequest<Either<BaseError, MultiCollectionViewModel>>;
+}

ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs

@@ -0,0 +1,117 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class CreateMultiCollectionHandler :
+        IRequestHandler<CreateMultiCollection, Either<BaseError, MultiCollectionViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public CreateMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, MultiCollectionViewModel>> Handle(
+            CreateMultiCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
+            return await validation.Apply(c => PersistCollection(dbContext, c));
+        }
+
+        private static async Task<MultiCollectionViewModel> PersistCollection(
+            TvContext dbContext,
+            MultiCollection multiCollection)
+        {
+            await dbContext.MultiCollections.AddAsync(multiCollection);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(multiCollection)
+                .Collection(c => c.MultiCollectionItems)
+                .Query()
+                .Include(i => i.Collection)
+                .LoadAsync();
+            await dbContext.Entry(multiCollection)
+                .Collection(c => c.MultiCollectionSmartItems)
+                .Query()
+                .Include(i => i.SmartCollection)
+                .LoadAsync();
+            return ProjectToViewModel(multiCollection);
+        }
+
+        private static Task<Validation<BaseError, MultiCollection>> Validate(
+            TvContext dbContext,
+            CreateMultiCollection request) =>
+            ValidateName(dbContext, request).MapT(
+                name => new MultiCollection
+                {
+                    Name = name,
+                    MultiCollectionItems = request.Items.Map(
+                            i =>
+                            {
+                                if (i.CollectionId.HasValue)
+                                {
+                                    return Some(
+                                        new MultiCollectionItem
+                                        {
+                                            CollectionId = i.CollectionId.Value,
+                                            ScheduleAsGroup = i.ScheduleAsGroup,
+                                            PlaybackOrder = i.PlaybackOrder
+                                        });
+                                }
+
+                                return None;
+                            })
+                        .Sequence()
+                        .Flatten()
+                        .ToList(),
+                    MultiCollectionSmartItems = request.Items.Map(
+                            i =>
+                            {
+                                if (i.SmartCollectionId.HasValue)
+                                {
+                                    return Some(
+                                        new MultiCollectionSmartItem
+                                        {
+                                            SmartCollectionId = i.SmartCollectionId.Value,
+                                            ScheduleAsGroup = i.ScheduleAsGroup,
+                                            PlaybackOrder = i.PlaybackOrder
+                                        });
+                                }
+
+                                return None;
+                            })
+                        .Sequence()
+                        .Flatten()
+                        .ToList()
+                });
+
+        private static async Task<Validation<BaseError, string>> ValidateName(
+            TvContext dbContext,
+            CreateMultiCollection createMultiCollection)
+        {
+            List<string> allNames = await dbContext.MultiCollections
+                .Map(c => c.Name)
+                .ToListAsync();
+
+            Validation<BaseError, string> result1 = createMultiCollection.NotEmpty(c => c.Name)
+                .Bind(_ => createMultiCollection.NotLongerThan(50)(c => c.Name));
+
+            var result2 = Optional(createMultiCollection.Name)
+                .Filter(name => !allNames.Contains(name))
+                .ToValidation<BaseError>("MultiCollection name must be unique");
+
+            return (result1, result2).Apply((_, _) => createMultiCollection.Name);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs

@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class CreateSmartCollectionHandler :
+        IRequestHandler<CreateSmartCollection, Either<BaseError, SmartCollectionViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public CreateSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, SmartCollectionViewModel>> Handle(
+            CreateSmartCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
+            return await validation.Apply(c => PersistCollection(dbContext, c));
+        }
+
+        private static async Task<SmartCollectionViewModel> PersistCollection(
+            TvContext dbContext,
+            SmartCollection smartCollection)
+        {
+            await dbContext.SmartCollections.AddAsync(smartCollection);
+            await dbContext.SaveChangesAsync();
+            return ProjectToViewModel(smartCollection);
+        }
+
+        private static Task<Validation<BaseError, SmartCollection>> Validate(
+            TvContext dbContext,
+            CreateSmartCollection request) =>
+            ValidateName(dbContext, request).MapT(
+                name => new SmartCollection
+                {
+                    Name = name,
+                    Query = request.Query
+                });
+
+        private static async Task<Validation<BaseError, string>> ValidateName(
+            TvContext dbContext,
+            CreateSmartCollection createSmartCollection)
+        {
+            List<string> allNames = await dbContext.SmartCollections
+                .Map(c => c.Name)
+                .ToListAsync();
+
+            Validation<BaseError, string> result1 = createSmartCollection.NotEmpty(c => c.Name)
+                .Bind(_ => createSmartCollection.NotLongerThan(50)(c => c.Name));
+
+            var result2 = Optional(createSmartCollection.Name)
+                .Filter(name => !allNames.Contains(name))
+                .ToValidation<BaseError>("SmartCollection name must be unique");
+
+            return (result1, result2).Apply((_, _) => createSmartCollection.Name);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollectionHandler.cs

@@ -0,0 +1,42 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class DeleteMultiCollectionHandler : MediatR.IRequestHandler<DeleteMultiCollection, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public DeleteMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteMultiCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            Validation<BaseError, MultiCollection> validation = await MultiCollectionMustExist(dbContext, request);
+            return await validation.Apply(c => DoDeletion(dbContext, c));
+        }
+
+        private static Task<Unit> DoDeletion(TvContext dbContext, MultiCollection multiCollection)
+        {
+            dbContext.MultiCollections.Remove(multiCollection);
+            return dbContext.SaveChangesAsync().ToUnit();
+        }
+
+        private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
+            TvContext dbContext,
+            DeleteMultiCollection request) =>
+            dbContext.MultiCollections
+                .SelectOneAsync(c => c.Id, c => c.Id == request.MultiCollectionId)
+                .Map(o => o.ToValidation<BaseError>($"MultiCollection {request.MultiCollectionId} does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollection.cs

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

ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs

@@ -0,0 +1,42 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class DeleteSmartCollectionHandler : MediatR.IRequestHandler<DeleteSmartCollection, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public DeleteSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteSmartCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            Validation<BaseError, SmartCollection> validation = await SmartCollectionMustExist(dbContext, request);
+            return await validation.Apply(c => DoDeletion(dbContext, c));
+        }
+
+        private static Task<Unit> DoDeletion(TvContext dbContext, SmartCollection smartCollection)
+        {
+            dbContext.SmartCollections.Remove(smartCollection);
+            return dbContext.SaveChangesAsync().ToUnit();
+        }
+
+        private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+            TvContext dbContext,
+            DeleteSmartCollection request) =>
+            dbContext.SmartCollections
+                .SelectOneAsync(c => c.Id, c => c.Id == request.SmartCollectionId)
+                .Map(o => o.ToValidation<BaseError>($"SmartCollection {request.SmartCollectionId} does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollection.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+
+    public record UpdateMultiCollection
+    (
+        int MultiCollectionId,
+        string Name,
+        List<UpdateMultiCollectionItem> Items) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs

@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateMultiCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            UpdateMultiCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
+            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
+        }
+
+        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, MultiCollection c, UpdateMultiCollection request)
+        {
+            c.Name = request.Name;
+            
+            // save name first so playouts don't get rebuilt for a name change
+            await dbContext.SaveChangesAsync();
+
+            var toAdd = request.Items
+                .Filter(i => i.CollectionId.HasValue)
+                // ReSharper disable once PossibleInvalidOperationException
+                .Filter(i => c.MultiCollectionItems.All(i2 => i2.CollectionId != i.CollectionId.Value))
+                .Map(i => new MultiCollectionItem
+                    {
+                        // ReSharper disable once PossibleInvalidOperationException
+                        CollectionId = i.CollectionId.Value,
+                        MultiCollectionId = c.Id,
+                        ScheduleAsGroup = i.ScheduleAsGroup,
+                        PlaybackOrder = i.PlaybackOrder
+                    })
+                .ToList();
+            var toRemove = c.MultiCollectionItems
+                .Filter(i => request.Items.All(i2 => i2.CollectionId != i.CollectionId))
+                .ToList();
+            
+            // remove items that are no longer present
+            c.MultiCollectionItems.RemoveAll(toRemove.Contains);
+            
+            // update existing items
+            foreach (MultiCollectionItem item in c.MultiCollectionItems)
+            {
+                foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
+                    i => i.CollectionId == item.CollectionId))
+                {
+                    item.ScheduleAsGroup = incoming.ScheduleAsGroup;
+                    item.PlaybackOrder = incoming.PlaybackOrder;
+                }
+            }
+
+            // add new items
+            c.MultiCollectionItems.AddRange(toAdd);
+
+            var toAddSmart = request.Items
+                .Filter(i => i.SmartCollectionId.HasValue)
+                // ReSharper disable once PossibleInvalidOperationException
+                .Filter(i => c.MultiCollectionSmartItems.All(i2 => i2.SmartCollectionId != i.SmartCollectionId.Value))
+                .Map(i => new MultiCollectionSmartItem
+                    {
+                        // ReSharper disable once PossibleInvalidOperationException
+                        SmartCollectionId = i.SmartCollectionId.Value,
+                        MultiCollectionId = c.Id,
+                        ScheduleAsGroup = i.ScheduleAsGroup,
+                        PlaybackOrder = i.PlaybackOrder
+                    })
+                .ToList();
+            var toRemoveSmart = c.MultiCollectionSmartItems
+                .Filter(i => request.Items.All(i2 => i2.SmartCollectionId != i.SmartCollectionId))
+                .ToList();
+            
+            // remove items that are no longer present
+            c.MultiCollectionSmartItems.RemoveAll(toRemoveSmart.Contains);
+            
+            // update existing items
+            foreach (MultiCollectionSmartItem item in c.MultiCollectionSmartItems)
+            {
+                foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
+                    i => i.SmartCollectionId == item.SmartCollectionId))
+                {
+                    item.ScheduleAsGroup = incoming.ScheduleAsGroup;
+                    item.PlaybackOrder = incoming.PlaybackOrder;
+                }
+            }
+
+            // add new items
+            c.MultiCollectionSmartItems.AddRange(toAddSmart);
+
+            // rebuild playouts
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingMultiCollection(
+                    request.MultiCollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, MultiCollection>> Validate(
+            TvContext dbContext,
+            UpdateMultiCollection request) =>
+            (await MultiCollectionMustExist(dbContext, request), await ValidateName(dbContext, request))
+            .Apply((collectionToUpdate, _) => collectionToUpdate);
+
+        private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
+            TvContext dbContext,
+            UpdateMultiCollection updateCollection) =>
+            dbContext.MultiCollections
+                .Include(mc => mc.MultiCollectionItems)
+                .Include(mc => mc.MultiCollectionSmartItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.MultiCollectionId)
+                .Map(o => o.ToValidation<BaseError>("MultiCollection does not exist."));
+
+        private static async Task<Validation<BaseError, string>> ValidateName(TvContext dbContext, UpdateMultiCollection updateMultiCollection)
+        {
+            List<string> allNames = await dbContext.MultiCollections
+                .Filter(mc => mc.Id != updateMultiCollection.MultiCollectionId)
+                .Map(c => c.Name)
+                .ToListAsync();
+
+            Validation<BaseError, string> result1 = updateMultiCollection.NotEmpty(c => c.Name)
+                .Bind(_ => updateMultiCollection.NotLongerThan(50)(c => c.Name));
+
+            var result2 = Optional(updateMultiCollection.Name)
+                .Filter(name => !allNames.Contains(name))
+                .ToValidation<BaseError>("MultiCollection name must be unique");
+
+            return (result1, result2).Apply((_, _) => updateMultiCollection.Name);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollection.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record UpdateSmartCollection(int Id, string Query) : IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public UpdateSmartCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            UpdateSmartCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
+            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
+        }
+
+        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, SmartCollection c, UpdateSmartCollection request)
+        {
+            c.Query = request.Query;
+
+            // rebuild playouts
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this smart collection
+                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingSmartCollection(request.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static Task<Validation<BaseError, SmartCollection>> Validate(
+            TvContext dbContext,
+            UpdateSmartCollection request) => SmartCollectionMustExist(dbContext, request);
+
+        private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+            TvContext dbContext,
+            UpdateSmartCollection updateCollection) =>
+            dbContext.SmartCollections
+                .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.Id)
+                .Map(o => o.ToValidation<BaseError>("SmartCollection does not exist."));
+    }
+}

ErsatzTV.Application/MediaCollections/Mapper.cs

@@ -1,10 +1,36 @@
-using ErsatzTV.Core.Domain;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.MediaCollections
 {
     internal static class Mapper
     {
         internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
-            new(collection.Id, collection.Name);
+            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder);
+
+        internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
+            new(
+                multiCollection.Id,
+                multiCollection.Name,
+                Optional(multiCollection.MultiCollectionItems).Flatten().Map(ProjectToViewModel).ToList(),
+                Optional(multiCollection.MultiCollectionSmartItems).Flatten().Map(ProjectToViewModel).ToList());
+
+        internal static SmartCollectionViewModel ProjectToViewModel(SmartCollection collection) =>
+            new(collection.Id, collection.Name, collection.Query);
+
+        private static MultiCollectionItemViewModel ProjectToViewModel(MultiCollectionItem multiCollectionItem) =>
+            new(
+                multiCollectionItem.MultiCollectionId,
+                ProjectToViewModel(multiCollectionItem.Collection),
+                multiCollectionItem.ScheduleAsGroup,
+                multiCollectionItem.PlaybackOrder);
+
+        private static MultiCollectionSmartItemViewModel ProjectToViewModel(MultiCollectionSmartItem multiCollectionSmartItem) =>
+            new(
+                multiCollectionSmartItem.MultiCollectionId,
+                ProjectToViewModel(multiCollectionSmartItem.SmartCollection),
+                multiCollectionSmartItem.ScheduleAsGroup,
+                multiCollectionSmartItem.PlaybackOrder);
     }
 }

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

@@ -2,7 +2,7 @@
 
 namespace ErsatzTV.Application.MediaCollections
 {
-    public record MediaCollectionViewModel(int Id, string Name) : MediaCardViewModel(
+    public record MediaCollectionViewModel(int Id, string Name, bool UseCustomPlaybackOrder) : MediaCardViewModel(
         Id,
         Name,
         string.Empty,

ErsatzTV.Application/MediaCollections/MultiCollectionItemViewModel.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record MultiCollectionItemViewModel(
+        int MultiCollectionId,
+        MediaCollectionViewModel Collection,
+        bool ScheduleAsGroup,
+        PlaybackOrder PlaybackOrder);
+}

ErsatzTV.Application/MediaCollections/MultiCollectionSmartItemViewModel.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record MultiCollectionSmartItemViewModel(
+        int MultiCollectionId,
+        SmartCollectionViewModel SmartCollection,
+        bool ScheduleAsGroup,
+        PlaybackOrder PlaybackOrder);
+}

ErsatzTV.Application/MediaCollections/MultiCollectionViewModel.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record MultiCollectionViewModel(
+        int Id,
+        string Name,
+        List<MultiCollectionItemViewModel> Items,
+        List<MultiCollectionSmartItemViewModel> SmartItems);
+}

ErsatzTV.Application/MediaCollections/PagedMultiCollectionsViewModel.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record PagedMultiCollectionsViewModel(int TotalCount, List<MultiCollectionViewModel> Page);
+}

ErsatzTV.Application/MediaCollections/PagedSmartCollectionsViewModel.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record PagedSmartCollectionsViewModel(int TotalCount, List<SmartCollectionViewModel> Page);
+}

ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollections.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollectionsHandler.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetAllMultiCollectionsHandler : IRequestHandler<GetAllMultiCollections, List<MultiCollectionViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetAllMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<List<MultiCollectionViewModel>> Handle(
+            GetAllMultiCollections request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.MultiCollections
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollections.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollectionsHandler.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetAllSmartCollectionsHandler : IRequestHandler<GetAllSmartCollections, List<SmartCollectionViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetAllSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<List<SmartCollectionViewModel>> Handle(
+            GetAllSmartCollections request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.SmartCollections
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionById.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionByIdHandler.cs

@@ -0,0 +1,33 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetMultiCollectionByIdHandler : IRequestHandler<GetMultiCollectionById, Option<MultiCollectionViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetMultiCollectionByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Option<MultiCollectionViewModel>> Handle(
+            GetMultiCollectionById request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.MultiCollections
+                .Include(mc => mc.MultiCollectionItems)
+                .ThenInclude(mc => mc.Collection)
+                .Include(mc => mc.MultiCollectionSmartItems)
+                .ThenInclude(mc => mc.SmartCollection)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+                .MapT(ProjectToViewModel);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs

@@ -33,6 +33,7 @@ namespace ErsatzTV.Application.MediaCollections.Queries
             List<MediaCollectionViewModel> page = await dbContext.Collections.FromSqlRaw(
                     @"SELECT * FROM Collection
                     ORDER BY Name
+                    COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
                     request.PageSize,
                     request.PageNum * request.PageSize)

ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollections.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public record GetPagedMultiCollections(int PageNum, int PageSize) : IRequest<PagedMultiCollectionsViewModel>;
+}

ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollectionsHandler.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetPagedMultiCollectionsHandler : IRequestHandler<GetPagedMultiCollections, PagedMultiCollectionsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedMultiCollectionsViewModel> Handle(
+            GetPagedMultiCollections request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM MultiCollection");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<MultiCollectionViewModel> page = await dbContext.MultiCollections.FromSqlRaw(
+                    @"SELECT * FROM MultiCollection
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .Include(mc => mc.MultiCollectionItems)
+                .ThenInclude(i => i.Collection)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedMultiCollectionsViewModel(count, page);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollections.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public record GetPagedSmartCollections(int PageNum, int PageSize) : IRequest<PagedSmartCollectionsViewModel>;
+}

ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollectionsHandler.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetPagedSmartCollectionsHandler : IRequestHandler<GetPagedSmartCollections, PagedSmartCollectionsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedSmartCollectionsViewModel> Handle(
+            GetPagedSmartCollections request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM SmartCollection");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<SmartCollectionViewModel> page = await dbContext.SmartCollections.FromSqlRaw(
+                    @"SELECT * FROM SmartCollection
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedSmartCollectionsViewModel(count, page);
+        }
+    }
+}

ErsatzTV.Application/MediaCollections/SmartCollectionViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record SmartCollectionViewModel(int Id, string Name, string Query);
+}

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -78,7 +78,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
                 decimal progressMin = (decimal) i / localLibrary.Paths.Count;
                 decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;
 
-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
                 DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
                 if (forceScan || nextScan < DateTimeOffset.Now)
                 {

ErsatzTV.Application/Movies/Mapper.cs

@@ -66,7 +66,7 @@ namespace ErsatzTV.Application.Movies
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
+                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
                 {
                     url.SetQueryParam("fillHeight", 440);
@@ -76,7 +76,7 @@ namespace ErsatzTV.Application.Movies
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
                 {
                     url.SetQueryParam("maxHeight", 440);

ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs

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

ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs

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

ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs

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

ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using ErsatzTV.Infrastructure.Data;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Playouts.Queries
 {
@@ -21,7 +22,13 @@ namespace ErsatzTV.Application.Playouts.Queries
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             return await dbContext.Playouts
                 .Filter(p => p.Channel != null && p.ProgramSchedule != null)
-                .Map(p => new PlayoutNameViewModel(p.Id, p.Channel.Name, p.Channel.Number, p.ProgramSchedule.Name))
+                .Map(
+                    p => new PlayoutNameViewModel(
+                        p.Id,
+                        p.Channel.Name,
+                        p.Channel.Number,
+                        p.ProgramSchedule.Name,
+                        Optional(p.DailyRebuildTime)))
                 .ToListAsync(cancellationToken);
         }
     }

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -64,7 +65,7 @@ namespace ErsatzTV.Application.Plex.Commands
 
         private async Task<Unit> Synchronize(RequestParameters parameters)
         {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
             DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
             if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
             {
@@ -74,13 +75,15 @@ namespace ErsatzTV.Application.Plex.Commands
                         await _plexMovieLibraryScanner.ScanLibrary(
                             parameters.ConnectionParameters.ActiveConnection,
                             parameters.ConnectionParameters.PlexServerAuthToken,
-                            parameters.Library);
+                            parameters.Library,
+                            parameters.FFprobePath);
                         break;
                     case LibraryMediaKind.Shows:
                         await _plexTelevisionLibraryScanner.ScanLibrary(
                             parameters.ConnectionParameters.ActiveConnection,
                             parameters.ConnectionParameters.PlexServerAuthToken,
-                            parameters.Library);
+                            parameters.Library,
+                            parameters.FFprobePath);
                         break;
                 }
 
@@ -100,13 +103,14 @@ namespace ErsatzTV.Application.Plex.Commands
 
         private async Task<Validation<BaseError, RequestParameters>> Validate(ISynchronizePlexLibraryById request) =>
             (await ValidateConnection(request), await PlexLibraryMustExist(request),
-                await ValidateLibraryRefreshInterval())
+                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
             .Apply(
-                (connectionParameters, plexLibrary, libraryRefreshInterval) => new RequestParameters(
+                (connectionParameters, plexLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
                     connectionParameters,
                     plexLibrary,
                     request.ForceScan,
-                    libraryRefreshInterval
+                    libraryRefreshInterval,
+                    ffprobePath
                 ));
 
         private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
@@ -149,12 +153,20 @@ namespace ErsatzTV.Application.Plex.Commands
             _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
                 .FilterT(lri => lri > 0)
                 .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+        
+        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,
             PlexLibrary Library,
             bool ForceScan,
-            int LibraryRefreshInterval);
+            int LibraryRefreshInterval,
+            string FFprobePath);
 
         private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)
         {

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -13,7 +13,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         PlayoutMode PlayoutMode,
         ProgramScheduleItemCollectionType CollectionType,
         int? CollectionId,
+        int? MultiCollectionId,
+        int? SmartCollectionId,
         int? MediaItemId,
+        PlaybackOrder PlaybackOrder,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
         bool? OfflineTail,

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs

@@ -7,7 +7,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
 {
     public record CreateProgramSchedule(
         string Name,
-        PlaybackOrder MediaCollectionPlaybackOrder,
         bool KeepMultiPartEpisodesTogether,
         bool TreatCollectionsAsShows) : IRequest<Either<BaseError, CreateProgramScheduleResult>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs

@@ -45,13 +45,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                 ValidateName(dbContext, request),
                 name =>
                 {
-                    bool keepMultiPartEpisodesTogether =
-                        request.MediaCollectionPlaybackOrder == PlaybackOrder.Shuffle &&
-                        request.KeepMultiPartEpisodesTogether;
+                    bool keepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
                     return new ProgramSchedule
                     {
                         Name = name,
-                        MediaCollectionPlaybackOrder = request.MediaCollectionPlaybackOrder,
                         KeepMultiPartEpisodesTogether = keepMultiPartEpisodesTogether,
                         TreatCollectionsAsShows = keepMultiPartEpisodesTogether && request.TreatCollectionsAsShows
                     };

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -8,8 +8,11 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         TimeSpan? StartTime { get; }
         ProgramScheduleItemCollectionType CollectionType { get; }
         int? CollectionId { get; }
+        int? MultiCollectionId { get; }
+        int? SmartCollectionId { get; }
         int? MediaItemId { get; }
         PlayoutMode PlayoutMode { get; }
+        PlaybackOrder PlaybackOrder { get; }
         int? MultipleCount { get; }
         TimeSpan? PlayoutDuration { get; }
         bool? OfflineTail { get; }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -24,15 +24,28 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             IProgramScheduleItemRequest item,
             ProgramSchedule programSchedule)
         {
+            if (item.MultiCollectionId.HasValue)
+            {
+                switch (item.PlaybackOrder)
+                {
+                    case PlaybackOrder.Chronological:
+                    case PlaybackOrder.Random:
+                        return BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'");
+                    case PlaybackOrder.Shuffle:
+                    case PlaybackOrder.ShuffleInOrder:
+                        break;
+                }
+            }
+
             switch (item.PlayoutMode)
             {
                 case PlayoutMode.Flood:
                 case PlayoutMode.One:
                     break;
                 case PlayoutMode.Multiple:
-                    if (item.MultipleCount.GetValueOrDefault() <= 0)
+                    if (item.MultipleCount.GetValueOrDefault() < 0)
                     {
-                        return BaseError.New("[MultipleCount] must be greater than 0 for playout mode 'multiple'");
+                        return BaseError.New("[MultipleCount] must be greater than or equal to 0 for playout mode 'multiple'");
                     }
 
                     break;
@@ -88,6 +101,20 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                         return BaseError.New("[MediaItem] is required for collection type 'Artist'");
                     }
 
+                    break;
+                case ProgramScheduleItemCollectionType.MultiCollection:
+                    if (item.MultiCollectionId is null)
+                    {
+                        return BaseError.New("[MultiCollection] is required for collection type 'MultiCollection'");
+                    }
+
+                    break;
+                case ProgramScheduleItemCollectionType.SmartCollection:
+                    if (item.SmartCollectionId is null)
+                    {
+                        return BaseError.New("[SmartCollection] is required for collection type 'SmartCollection'");
+                    }
+
                     break;
                 default:
                     return BaseError.New("[CollectionType] is invalid");
@@ -109,7 +136,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
+                    MultiCollectionId = item.MultiCollectionId,
+                    SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
+                    PlaybackOrder = item.PlaybackOrder,
                     CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.One => new ProgramScheduleItemOne
@@ -119,7 +149,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
+                    MultiCollectionId = item.MultiCollectionId,
+                    SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
+                    PlaybackOrder = item.PlaybackOrder,
                     CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.Multiple => new ProgramScheduleItemMultiple
@@ -129,7 +162,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
+                    MultiCollectionId = item.MultiCollectionId,
+                    SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
+                    PlaybackOrder = item.PlaybackOrder,
                     Count = item.MultipleCount.GetValueOrDefault(),
                     CustomTitle = item.CustomTitle
                 },
@@ -140,7 +176,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
+                    MultiCollectionId = item.MultiCollectionId,
+                    SmartCollectionId = item.SmartCollectionId,
                     MediaItemId = item.MediaItemId,
+                    PlaybackOrder = item.PlaybackOrder,
                     PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
                     OfflineTail = item.OfflineTail.GetValueOrDefault(),
                     CustomTitle = item.CustomTitle

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -14,7 +14,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         PlayoutMode PlayoutMode,
         ProgramScheduleItemCollectionType CollectionType,
         int? CollectionId,
+        int? MultiCollectionId,
+        int? SmartCollectionId,
         int? MediaItemId,
+        PlaybackOrder PlaybackOrder,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
         bool? OfflineTail,

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs

@@ -11,6 +11,7 @@ using LanguageExt;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.ProgramSchedules.Commands
 {
@@ -61,7 +62,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             ReplaceProgramScheduleItems request) =>
             ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
                 .BindT(programSchedule => PlayoutModesMustBeValid(request, programSchedule))
-                .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule));
+                .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
+                .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule));
 
         private static Validation<BaseError, ProgramSchedule> PlayoutModesMustBeValid(
             ReplaceProgramScheduleItems request,
@@ -74,5 +76,43 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             ProgramSchedule programSchedule) =>
             request.Items.Map(item => CollectionTypeMustBeValid(item, programSchedule)).Sequence()
                 .Map(_ => programSchedule);
+
+        private static Validation<BaseError, ProgramSchedule> PlaybackOrdersMustBeValid(
+            ReplaceProgramScheduleItems request,
+            ProgramSchedule programSchedule)
+        {
+            var keyOrders = new Dictionary<CollectionKey, System.Collections.Generic.HashSet<PlaybackOrder>>();
+            foreach (ReplaceProgramScheduleItem item in request.Items)
+            {
+                var key = new CollectionKey(
+                    item.CollectionType,
+                    item.CollectionId,
+                    item.MediaItemId,
+                    item.MultiCollectionId,
+                    item.SmartCollectionId);
+
+                if (keyOrders.TryGetValue(key, out System.Collections.Generic.HashSet<PlaybackOrder> playbackOrders))
+                {
+                    playbackOrders.Add(item.PlaybackOrder);
+                    keyOrders[key] = playbackOrders;
+                }
+                else
+                {
+                    keyOrders.Add(key, new System.Collections.Generic.HashSet<PlaybackOrder> { item.PlaybackOrder });
+                }
+            }
+
+            return Optional(keyOrders.Values.Count(set => set.Count != 1))
+                .Filter(count => count == 0)
+                .Map(_ => programSchedule)
+                .ToValidation<BaseError>("A collection must not use multiple playback orders");
+        }
+
+        private record CollectionKey(
+            ProgramScheduleItemCollectionType CollectionType,
+            int? CollectionId,
+            int? MediaItemId,
+            int? MultiCollectionId,
+            int? SmartCollectionId);
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs

@@ -9,7 +9,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
     (
         int ProgramScheduleId,
         string Name,
-        PlaybackOrder MediaCollectionPlaybackOrder,
         bool KeepMultiPartEpisodesTogether,
         bool TreatCollectionsAsShows) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs

@@ -44,15 +44,11 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         {
             // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
             bool needToRebuildPlayout =
-                programSchedule.MediaCollectionPlaybackOrder != request.MediaCollectionPlaybackOrder ||
                 programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
                 programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows;
 
             programSchedule.Name = request.Name;
-            programSchedule.MediaCollectionPlaybackOrder = request.MediaCollectionPlaybackOrder;
-            programSchedule.KeepMultiPartEpisodesTogether =
-                request.MediaCollectionPlaybackOrder == PlaybackOrder.Shuffle &&
-                request.KeepMultiPartEpisodesTogether;
+            programSchedule.KeepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
             programSchedule.TreatCollectionsAsShows = programSchedule.KeepMultiPartEpisodesTogether &&
                                                       request.TreatCollectionsAsShows;
 

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -9,7 +9,6 @@ namespace ErsatzTV.Application.ProgramSchedules
             new(
                 programSchedule.Id,
                 programSchedule.Name,
-                programSchedule.MediaCollectionPlaybackOrder,
                 programSchedule.KeepMultiPartEpisodesTogether,
                 programSchedule.TreatCollectionsAsShows);
 
@@ -26,6 +25,12 @@ namespace ErsatzTV.Application.ProgramSchedules
                         duration.Collection != null
                             ? MediaCollections.Mapper.ProjectToViewModel(duration.Collection)
                             : null,
+                        duration.MultiCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(duration.MultiCollection)
+                            : null,
+                        duration.SmartCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(duration.SmartCollection)
+                            : null,
                         duration.MediaItem switch
                         {
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
@@ -33,6 +38,7 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
                             _ => null
                         },
+                        duration.PlaybackOrder,
                         duration.PlayoutDuration,
                         duration.OfflineTail,
                         duration.CustomTitle),
@@ -46,6 +52,12 @@ namespace ErsatzTV.Application.ProgramSchedules
                         flood.Collection != null
                             ? MediaCollections.Mapper.ProjectToViewModel(flood.Collection)
                             : null,
+                        flood.MultiCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(flood.MultiCollection)
+                            : null,
+                        flood.SmartCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(flood.SmartCollection)
+                            : null,
                         flood.MediaItem switch
                         {
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
@@ -53,6 +65,7 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
                             _ => null
                         },
+                        flood.PlaybackOrder,
                         flood.CustomTitle),
                 ProgramScheduleItemMultiple multiple =>
                     new ProgramScheduleItemMultipleViewModel(
@@ -64,6 +77,12 @@ namespace ErsatzTV.Application.ProgramSchedules
                         multiple.Collection != null
                             ? MediaCollections.Mapper.ProjectToViewModel(multiple.Collection)
                             : null,
+                        multiple.MultiCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(multiple.MultiCollection)
+                            : null,
+                        multiple.SmartCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(multiple.SmartCollection)
+                            : null,
                         multiple.MediaItem switch
                         {
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
@@ -71,6 +90,7 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
                             _ => null
                         },
+                        multiple.PlaybackOrder,
                         multiple.Count,
                         multiple.CustomTitle),
                 ProgramScheduleItemOne one =>
@@ -83,6 +103,12 @@ namespace ErsatzTV.Application.ProgramSchedules
                         one.Collection != null
                             ? MediaCollections.Mapper.ProjectToViewModel(one.Collection)
                             : null,
+                        one.MultiCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(one.MultiCollection)
+                            : null,
+                        one.SmartCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(one.SmartCollection)
+                            : null,
                         one.MediaItem switch
                         {
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
@@ -90,6 +116,7 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
                             _ => null
                         },
+                        one.PlaybackOrder,
                         one.CustomTitle),
                 _ => throw new NotSupportedException(
                     $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -14,7 +14,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
+            MultiCollectionViewModel multiCollection,
+            SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
+            PlaybackOrder playbackOrder,
             TimeSpan playoutDuration,
             bool offlineTail,
             string customTitle) : base(
@@ -25,7 +28,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Duration,
             collectionType,
             collection,
+            multiCollection,
+            smartCollection,
             mediaItem,
+            playbackOrder,
             customTitle)
         {
             PlayoutDuration = playoutDuration;

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -14,7 +14,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
+            MultiCollectionViewModel multiCollection,
+            SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
+            PlaybackOrder playbackOrder,
             string customTitle) : base(
             id,
             index,
@@ -23,7 +26,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Flood,
             collectionType,
             collection,
+            multiCollection,
+            smartCollection,
             mediaItem,
+            playbackOrder,
             customTitle)
         {
         }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -14,7 +14,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
+            MultiCollectionViewModel multiCollection,
+            SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
+            PlaybackOrder playbackOrder,
             int count,
             string customTitle) : base(
             id,
@@ -24,7 +27,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Multiple,
             collectionType,
             collection,
+            multiCollection,
+            smartCollection,
             mediaItem,
+            playbackOrder,
             customTitle) =>
             Count = count;
 

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -14,7 +14,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
+            MultiCollectionViewModel multiCollection,
+            SmartCollectionViewModel smartCollection,
             NamedMediaItemViewModel mediaItem,
+            PlaybackOrder playbackOrder,
             string customTitle) : base(
             id,
             index,
@@ -23,7 +26,10 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.One,
             collectionType,
             collection,
+            multiCollection,
+            smartCollection,
             mediaItem,
+            playbackOrder,
             customTitle)
         {
         }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -13,7 +13,10 @@ namespace ErsatzTV.Application.ProgramSchedules
         PlayoutMode PlayoutMode,
         ProgramScheduleItemCollectionType CollectionType,
         MediaCollectionViewModel Collection,
+        MultiCollectionViewModel MultiCollection,
+        SmartCollectionViewModel SmartCollection,
         NamedMediaItemViewModel MediaItem,
+        PlaybackOrder PlaybackOrder,
         string CustomTitle)
     {
         public string Name => CollectionType switch
@@ -25,6 +28,10 @@ namespace ErsatzTV.Application.ProgramSchedules
                 MediaItem?.Name, // $"{TelevisionSeason?.Title} ({TelevisionSeason?.Plot})",
             ProgramScheduleItemCollectionType.Artist =>
                 MediaItem?.Name,
+            ProgramScheduleItemCollectionType.MultiCollection =>
+                MultiCollection?.Name,
+            ProgramScheduleItemCollectionType.SmartCollection =>
+                SmartCollection?.Name,
             _ => string.Empty
         };
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs

@@ -1,11 +1,8 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.ProgramSchedules
+namespace ErsatzTV.Application.ProgramSchedules
 {
     public record ProgramScheduleViewModel(
         int Id,
         string Name,
-        PlaybackOrder MediaCollectionPlaybackOrder,
         bool KeepMultiPartEpisodesTogether,
         bool TreatCollectionsAsShows);
 }

ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs

@@ -24,7 +24,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                     ps => new ProgramScheduleViewModel(
                         ps.Id,
                         ps.Name,
-                        ps.MediaCollectionPlaybackOrder,
                         ps.KeepMultiPartEpisodesTogether,
                         ps.TreatCollectionsAsShows))
                 .ToListAsync(cancellationToken);

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs

@@ -27,6 +27,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
             return await dbContext.ProgramScheduleItems
                 .Filter(psi => psi.ProgramScheduleId == request.Id)
                 .Include(i => i.Collection)
+                .Include(i => i.MultiCollection)
+                .Include(i => i.SmartCollection)
                 .Include(i => i.MediaItem)
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -99,6 +99,10 @@ namespace ErsatzTV.Application.Streaming.Queries
                             watermarkId => dbContext.ChannelWatermarks
                                 .SelectOneAsync(w => w.Id, w => w.Id == watermarkId));
 
+                    Option<VaapiDriver> maybeVaapiDriver = await dbContext.ConfigElements
+                        .GetValue<int>(ConfigElementKey.FFmpegVaapiDriver)
+                        .MapT(i => (VaapiDriver)i);
+
                     return Right<BaseError, Process>(
                         await _ffmpegProcessService.ForPlayoutItem(
                             ffmpegPath,
@@ -108,7 +112,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                             playoutItemWithPath.Path,
                             playoutItemWithPath.PlayoutItem.StartOffset,
                             now,
-                            maybeGlobalWatermark));
+                            maybeGlobalWatermark,
+                            maybeVaapiDriver));
                 },
                 async error =>
                 {

ErsatzTV.Application/Television/Mapper.cs

@@ -80,7 +80,7 @@ namespace ErsatzTV.Application.Television
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
+                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind == ArtworkKind.Poster)
                 {
                     url.SetQueryParam("fillHeight", 440);
@@ -90,7 +90,7 @@ namespace ErsatzTV.Application.Television
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind == ArtworkKind.Poster)
                 {
                     url.SetQueryParam("maxHeight", 440);

ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj

@@ -10,17 +10,17 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="FluentAssertions" Version="5.10.3" />
+      <PackageReference Include="FluentAssertions" Version="6.1.0" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
-      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
       <PackageReference Include="Moq" Version="4.16.1" />
       <PackageReference Include="NUnit" Version="3.13.2" />
-      <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
+      <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
       <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />

ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs

@@ -4,6 +4,7 @@ using ErsatzTV.Core.FFmpeg;
 using FluentAssertions;
 using LanguageExt;
 using NUnit.Framework;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Tests.FFmpeg
 {
@@ -113,6 +114,161 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     });
             }
 
+            [Test]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.BottomLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.BottomRight,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopRight,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                true,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=54:enable='lt(mod(mod(time(0),60*60),10*60),15)'[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                true,
+                100,
+                "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                90,
+                "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,colorchannelmixer=aa=0.90[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                true,
+                100,
+                "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                true,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+                "[a]",
+                "[v]")]
+            [TestCase(
+                true,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
+                "[a]",
+                "[v]")]
+            public void Should_Return_Watermark(
+                bool alignAudio,
+                bool deinterlace,
+                bool intermittent,
+                ChannelWatermarkLocation location,
+                bool scaled,
+                int opacity,
+                string expectedVideoFilter,
+                string expectedAudioLabel,
+                string expectedVideoLabel)
+            {
+                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                    .WithWatermark(
+                        Some(
+                            new ChannelWatermark
+                            {
+                                Mode = intermittent
+                                    ? ChannelWatermarkMode.Intermittent
+                                    : ChannelWatermarkMode.Permanent,
+                                DurationSeconds = intermittent ? 15 : 0,
+                                FrequencyMinutes = intermittent ? 10 : 0,
+                                Location = location,
+                                Size = scaled ? ChannelWatermarkSize.Scaled : ChannelWatermarkSize.ActualSize,
+                                WidthPercent = scaled ? 20 : 0,
+                                Opacity = opacity,
+                                HorizontalMarginPercent = 7,
+                                VerticalMarginPercent = 5
+                            }),
+                        new Resolution { Width = 1920, Height = 1080 })
+                    .WithDeinterlace(deinterlace)
+                    .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
+
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+
+                result.IsSome.Should().BeTrue();
+                result.IfSome(
+                    filter =>
+                    {
+                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                        filter.AudioLabel.Should().Be(expectedAudioLabel);
+                        filter.VideoLabel.Should().Be(expectedVideoLabel);
+                    });
+            }
+
             [Test]
             [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
             [TestCase(

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -258,6 +258,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
@@ -283,6 +284,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1280, Height = 720 }
                 };
@@ -309,6 +311,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
@@ -334,6 +337,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeVideo = false,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
@@ -359,6 +363,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoCodec = "testCodec"
@@ -387,6 +392,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoCodec = "testCodec"
@@ -416,6 +422,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoCodec = "testCodec"
@@ -444,6 +451,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoCodec = "libx264"
@@ -473,6 +481,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = false,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoCodec = "libx264"
@@ -495,12 +504,47 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 actual.PadToDesiredResolution.Should().BeFalse();
                 actual.VideoCodec.Should().Be("copy");
             }
+            
+            [Test]
+            public void
+                Should_SetCopyVideoCodec_AndCopyAudioCodec_When_NotTranscoding_ForTransportStream()
+            {
+                var ffmpegProfile = new FFmpegProfile
+                {
+                    Transcode = false,
+                    NormalizeVideo = true,
+                    NormalizeAudio = true,
+                    NormalizeLoudness = true,
+                    Resolution = new Resolution { Width = 1920, Height = 1080 },
+                    VideoCodec = "libx264"
+                };
+
+                // not anamorphic
+                var version = new MediaVersion
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream { Codec = "mpeg2video" },
+                    new MediaStream(),
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                actual.ScaledSize.IsNone.Should().BeTrue();
+                actual.PadToDesiredResolution.Should().BeFalse();
+                actual.VideoCodec.Should().Be("copy");
+                actual.NormalizeLoudness.Should().BeFalse();
+                actual.AudioCodec.Should().Be("copy");
+            }
 
             [Test]
             public void Should_SetVideoBitrate_When_ContentIsPadded_ForTransportStream()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoBitrate = 2525
@@ -528,6 +572,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoBitrate = 2525
@@ -556,6 +601,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoBufferSize = 2525
@@ -584,6 +630,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
+                    Transcode = true,
                     NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
                     VideoBufferSize = 2525
@@ -612,6 +659,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
@@ -658,6 +706,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
@@ -681,6 +730,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
@@ -704,6 +754,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioBitrate = 2424,
                     AudioCodec = "ac3"
@@ -728,6 +779,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioBufferSize = 2424,
                     AudioCodec = "ac3"
@@ -752,6 +804,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioCodec = "ac3",
                     AudioChannels = 6
@@ -776,6 +829,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioCodec = "ac3",
                     AudioSampleRate = 48
@@ -800,6 +854,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioChannels = 6
                 };
@@ -823,6 +878,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioSampleRate = 48
                 };
@@ -846,6 +902,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     AudioSampleRate = 48,
                     AudioCodec = "ac3"
@@ -870,6 +927,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = true,
                     NormalizeLoudness = true
                 };
@@ -893,6 +951,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
+                    Transcode = true,
                     NormalizeAudio = false,
                     NormalizeLoudness = true
                 };

ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs

@@ -4,6 +4,6 @@ namespace ErsatzTV.Core.Tests.Fakes
 {
     public record FakeFileEntry(string Path)
     {
-        public DateTime LastWriteTime { get; set; } = DateTime.MinValue;
+        public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
     }
 }

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -41,7 +41,7 @@ namespace ErsatzTV.Core.Tests.Fakes
         public DateTime GetLastWriteTime(string path) =>
             Optional(_files.SingleOrDefault(f => f.Path == path))
                 .Map(f => f.LastWriteTime)
-                .IfNone(DateTime.MinValue);
+                .IfNone(SystemTime.MinValueUtc);
 
         public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
             _files.Any(f => f.Path.StartsWith(libraryPath.Path + Path.DirectorySeparatorChar));

ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using LanguageExt;
 
 namespace ErsatzTV.Core.Tests.Fakes
@@ -18,7 +19,23 @@ namespace ErsatzTV.Core.Tests.Fakes
             throw new NotSupportedException();
 
         public Task<List<MediaItem>> GetItems(int id) => _data[id].ToList().AsTask();
+        public Task<List<MediaItem>> GetMultiCollectionItems(int id) => throw new NotSupportedException();
+        public Task<List<MediaItem>> GetSmartCollectionItems(int id) => throw new NotSupportedException();
+
+        public Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id) =>
+            throw new NotSupportedException();
+
+        public Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId) =>
+            throw new NotSupportedException();
+
         public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) => throw new NotSupportedException();
+
+        public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
+            throw new NotSupportedException();
+
+        public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
+            throw new NotSupportedException();
+
         public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
     }
 }

ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs

@@ -91,7 +91,32 @@ namespace ErsatzTV.Core.Tests.Metadata
                 });
 
             metadata.Count.Should().Be(2);
-            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(episode1, episode2);
+            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
+        }
+
+        [Test]
+        [TestCase("Something (2021).mkv", "Something")]
+        [TestCase("Something Else (2021).mkv", "Something Else")]
+        public void GetFallbackMetadata_Should_Set_Proper_Movie_Title(string path, string expectedTitle)
+        {
+            MovieMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+                new Movie
+                {
+                    LibraryPath = new LibraryPath(),
+                    MediaVersions = new List<MediaVersion>
+                    {
+                        new()
+                        {
+                            MediaFiles = new List<MediaFile>
+                            {
+                                new() { Path = path }
+                            }
+                        }
+                    }
+                });
+
+            metadata.Should().NotBeNull();
+            metadata.Title.Should().Be(expectedTitle);
         }
     }
 }