update changelog for release 44 [no docker]

* exclude strm files from jellyfin scanners

* update changelog

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2020.3.2",
+      "version": "2021.1.3",
       "commands": [
         "jb"
       ]

.github/workflows/release.yml

@@ -42,7 +42,7 @@ jobs:
           #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 }}"
+          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

CHANGELOG.md

@@ -0,0 +1,464 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
+
+## [0.0.44-prealpha] - 2021-06-09
+### Added
+- Add artists directly to schedules
+- Include MPAA and VCHIP content ratings in XMLTV guide data
+- Quickly skip missing files during Plex library scan
+
+### Fixed
+- Ignore unsupported plex guids (this prevented some libraries from scanning correctly)
+- Ignore unsupported STRM files from Jellyfin
+
+## [0.0.43-prealpha] - 2021-06-05
+### Added
+- Support `(Part #)` name suffixes for multi-part episode grouping
+- Support multi-episode files in local and Plex libraries
+- Save Channels table page size
+- Add optional query string parameter to M3U channel playlist to allow some customization per client
+    - `?mode=ts` will force `MPEG-TS` mode for all channels
+    - `?mode=hls-direct` will force `HLS Direct` mode for all channels
+    - `?mode=mixed` or no parameter will maintain existing behavior
+
+### Changed
+- Rename channel mode `TransportStream` to `MPEG-TS` and `HttpLiveStreaming` to `HLS Direct`
+- Improve `HLS Direct` mode compatibility with Channels DVR Server
+
+### Fixed
+- Fix search result crashes due to missing season metadata
+
+## [0.0.42-prealpha] - 2021-05-31
+### Added
+- Support roman numerals and english integer names for multi-part episode grouping
+- Add option to treat entire collection as a single show with multi-part episode grouping
+    - This is useful for multi-part episodes that span multiple shows (crossovers)
+
+### Changed
+- Skip zero duration items when building a playout, rather than aborting the playout build
+
+### Fixed
+- Fix edge case where a playout rebuild would get stuck and block all other playouts and local library scans
+
+## [0.0.41-prealpha] - 2021-05-30
+### Added
+- Add button to refresh list of Plex, Jellyfin, Emby libraries without restarting app
+- Add episodes to search index
+- Add director and writer metadata to episodes
+- Add unique id/provider id metadata, which will support future features
+- Allow grouping multi-part episodes with titles ending in `Part X`, `Part Y`, etc.
+
+### Changed
+- Change home page link from release notes to full changelog
+
+### Fixed
+- Fix missing channel logos after restart
+- Fix multi-part episode grouping with missing episodes/parts
+- Fix multi-part episode grouping in collections containing multiple shows
+- Fix updating modified seasons and episodes from Jellyfin and Emby
+
+## [0.0.40-prealpha] - 2021-05-28
+### Added
+- Add content rating metadata to movies and shows
+- Add director and writer metadata to movies
+- Sync tv show thumbnail artwork in Local, Jellyfin and Emby libraries (*not* Plex)
+- Prioritize tv show thumbnail artwork over tv show posters in XMLTV
+- Include tv show artwork in XMLTV when grouped items with custom title are all from the same show
+- Cache resized local artwork on disk
+
+### Fixed
+- Recursively retrieve Jellyfin and Emby items
+- Fix incorrect search item counts
+- Fix stack trace information in non-docker releases
+- Fix crash opening `Add to Schedule` dialog
+- Disable FFmpeg troubleshooting reports on Windows as they do not work properly
+
+## [0.0.39-prealpha] - 2021-05-25
+### Added
+- Show Jellyfin and Emby artwork in XMLTV
+
+### Fixed
+- Fix path replacements for Jellyfin and Emby, including UNC paths
+- Use Emby path replacements for playback
+- Fix playback when `fps` is the only required filter
+- Fix resources (images, fonts) required to display offline channel message
+
+## [0.0.38-prealpha] - 2021-05-23
+### Added
+- Add support for Emby
+- Use "single-file" deployments for releases
+    - Non-docker releases will have significantly fewer files
+    - It is recommended to empty your installation folder before copying in the latest release.
+
+### Fixed
+- Fix some cases where Jellyfin artwork would not display
+- Fix saving schedule items with duration less than one hour
+- Use ffmpeg 4.3 in docker images; there was a performance regression with 4.4 (only in docker)
+
+## [0.0.37-prealpha] - 2021-05-21
+### Added
+- Add option to keep multi-part episodes together when shuffling (i.e. two-part season finales)
+- Optimize Plex TV Scanner to quickly process shows that have not been updated since the last scan
+- Optimize local Movie, Show, Music Video scanners to quickly skip unchanged folders, and to notice any mtime change
+- Add server binding configuration to `appsettings.json` which lets non-docker installations bind to localhost or change the port number
+
+### Fixed
+- Properly ignore `Other` Jellyfin libraries
+- Fix bug where search index would try to re-initialize unnecessarily
+- Fix one cause of green line at bottom of some transcoded videos by forcing even scaling targets
+
+## [0.0.36-prealpha] - 2021-05-16
+### Added
+- Add support for Jellyfin
+- Add support for ffmpeg 4.4, and use ffmpeg 4.4 in all docker images
+- Add configurable library refresh interval
+- Add button to copy/clone ffmpeg profile
+
+## [0.0.35-prealpha] - 2021-04-27
+### Added
+- Add search button for each library in `Libraries` page to quickly filter content by library
+    - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Fixed
+- Fix ingesting actors and actor artwork from newly-added Plex media items
+- Only show `movie` and `show` libraries from Plex. Other library types are not supported at this time.
+- Fix local movie scanner missing replaced/updated files
+
+## [0.0.34-prealpha] - 2021-04-17
+### Added
+- Allow `enter` key to submit all dialogs
+- Add actors to movies and shows (Plex or NFO metadata is required)
+    - Note that this requires a one-time full library scan to ingest actor metadata, which may take a long time with large libraries.
+- Rework metadata list links in UI (languages, studios, genres, etc)
+
+### Fixed
+- Fix EPG generation with music video channels that do not use a custom title
+- Fix lag when typing in search bar, `Add To Collection` dialog
+- Fix collections paging
+- Fix padding odd resolutions (this bug caused some items to always fail playback)
+- Only update Plex episode artwork as needed
+
+## [0.0.33-prealpha] - 2021-04-11
+### Added
+- Add language buttons to movies, shows, artists
+- Show release notes on home page
+
+### Fixed
+- Re-import missing television metadata that was incorrectly removed with `v0.0.32`
+- Fix language indexing; language searches now use full english name
+- Fix synchronizing television studios, genres from Plex
+- Limit channels to one playout per channel
+    - Though more than one playout was previously possible it was unsupported and unlikely to work as expected, if at all
+    - A future release may make this possible again
+    
+## [0.0.32-prealpha] - 2021-04-09
+### Added
+- `Add All To Collection` button to quickly add all search results to a collection
+- Add Artists scanned from Music Video libraries
+    - Artist folders are now required, but music videos now have no naming requirements
+    - `artist.nfo` metadata is supported along with thumbnail and poster artwork
+- Save Collections table page size in local storage
+
+### Fixed
+- Fix audio stream language indexing for movies and music videos
+- Fix synchronizing list of Plex servers and connection addresses for each server
+- Fix `See All` link for music video search results
+
+## [0.0.31-prealpha] - 2021-04-06
+### Added
+- Add documentation link to UI
+- Add `language` search field
+- Minor log viewer improvements
+- Use fragment navigation with letter bar (clicking a letter will page and scroll until that letter is in view)
+- Send all audio streams with HLS when channel has no preferred language
+- Move FFmpeg settings to new `Settings` page
+- Add HDHR tuner count setting to new `Settings` page
+
+### Fixed
+- Fix poster width
+- Fix bug that would occasionally prevent items from being added to the search index
+- Automatically refresh the Plex Media Sources page after sign in or sign out
+
+## 0.0.30-prealpha [YANKED]
+
+## [0.0.29-prealpha] - 2021-04-04
+- No longer require NFO metadata for music videos
+    - Instead, the only requirement is that music video files be named `[artist] - [track].[extension]` where the three characters (space dash space) between artist and track are required
+- Add library scan progress detail
+- Optimize library scans after adding library path to only scan new library path
+- Fix bug replacing music videos
+- Scan Plex libraries and local libraries on different threads
+- Use English names for preferred languages in UI instead of ISO language code
+
+## [0.0.28-prealpha] - 2021-04-03
+- Apply audio normalization more consistently; this should further reduce program boundary errors
+- Replace unused audio volume setting with audio loudness normalization option
+    - This can be particularly helpful with music video channels if media items have inconsistent loudness
+    - This setting may be less desirable on movie channels where loudness is intended to be dynamic
+- Fix XMLTV containing music videos that do not use a custom title
+- Fix channels table sorting, add paging to channels table
+- Add sorting and paging to schedules table
+- Add paging to playouts table
+- Use table instead of cards for collections view
+
+## [0.0.27-prealpha] - 2021-04-02
+- Add ***basic*** music video library support
+    - **NFO metadata is required for music videos** - see [tags](https://kodi.wiki/view/NFO_files/Music_videos#Music_Video_Tags), [template](https://kodi.wiki/view/NFO_files/Music_videos#Template_nfo) and [sample](https://kodi.wiki/view/NFO_files/Music_videos#Sample_nfo)
+    - Artists can be searched using the `artist` field, like `artist:daft`
+- Clear search query when clicking `Movies` or `TV Shows` from paged search results
+- Add show title to playout details
+- Let ffmpeg determine thread count by default (signified by `0` threads in ffmpeg profile)
+- Save troubleshooting reports for ffmpeg concat process in addition to transcode process
+- Simplify ffmpeg normalization options
+- Add frame rate setting to ffmpeg profile
+    - When video normalization is enabled, all media items will have their frame rate converted to the same value
+- Fix some scenarios where streaming would freeze at program boundaries
+- Fix bug preventing some Plex libraries from scanning
+- Fix bug preventing some local libraries from scanning folders that were recently added
+
+## [0.0.26-prealpha] - 2021-03-30
+- Add `Custom Title` option to schedule items
+    - When a custom title is set, the schedule item will be grouped in the EPG with the custom title
+- Navigate to schedule items after creating new schedule
+- Fix channel editor so preferred language is no longer required on every channel
+- Fix bug with audio track selection during non-normalized playback
+- Fix bug with playout builds where `Multiple` or `Duration` items wouldn't respect the settings over time
+- Fix bug that prevented some television folders from scanning
+
+## [0.0.25-prealpha] - 2021-03-29
+- Add preferred language feature
+    - Global preference can be set in FFmpeg settings; channels can override global preference
+    - Preferences require [ISO 639-2](https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes) language codes
+    - Audio stream selection will attempt to respect these preferences and prioritize streams with the most channels
+    - English (`eng`) will be used as a fallback when no preferences have been configured
+    - ***This feature requires a one-time reanalysis of every media item which may take a long time for large libraries and playback may fail until this scan has completed***
+- Fix channel sorting in EPG
+- Fix mixed-platform path replacements (Plex on Windows with ErsatzTV on Linux, or Plex on Linux with ErsatzTV on Windows)
+- Fix local television library scanning; this was broken with `v0.0.23`
+- Optimize local library scanning; regular scans should be significantly faster
+- Add log warning when a zero-duration media item is encountered
+- Fix indexing local shows without NFO metadata.
+    - If you have this issue the best way to fix is to:
+        - Shutdown ErsatzTV
+        - Delete the `search-index` subfolder inside the ErsatzTV config folder
+        - Start ErsatzTV; the full search index will be rebuilt on startup
+- Fix updating search index when genres, tags, studios are updated in local libraries
+- Adjust artwork routes so all IPTV traffic can be proxied with a single path prefix of `/iptv`
+
+## [0.0.24-prealpha] - 2021-03-22
+- Fix a critical bug preventing library synchronization with Plex sign ins performed with `v0.0.22` or `v0.0.23`
+    - **If you are unable to sync libraries from Plex, please sign out and back in to apply this fix**
+- Fallback to `folder.jpg` when `poster.jpg` is not present
+- Attach episodes to correct show when adding NFO metadata to existing libraries
+
+## [0.0.23-prealpha] - 2021-03-21
+- Remove all Plex items from search index after sign out
+- Fix fallback metadata for local episodes (episode number was missing)
+- Improve television show year detection where year is missing from nfo metadata
+- Fix sorting for titles that start with `A` or `An` in addition to `The`
+- Properly escape search links containing special characters (genre, tag)
+- Add and index `Studio` metadata
+
+## [0.0.22-prealpha] - 2021-03-20
+- Log errors encountered during search index build; attempt to continue with partial index when errors are encountered
+- Only search `title` field by default; `genre` and `tag` can be searched with `field:query` syntax
+- Allow leading wildcards in searches
+- Keep search query in search field to allow easy modification
+- Fix default ffmpeg profile when creating new channels
+- Fix multiple bugs with updating Plex servers, libraries, path replacements
+- Add `release_date` to search index
+
+## [0.0.21-prealpha] - 2021-03-20
+- Optimize local library scanning to use less memory
+- Duplicate some documentation near the schedule item editor
+- Fix bug with updating `Normalize Video Codec` setting
+- Rework search functionality
+    - Search landing page will show up to 50 items of each type
+    - `See All` links can be used to page through all search results
+    - Complex search queries supported (`christmas OR santa`)
+    - Fields that are searched by default:
+        - `title`
+        - `genre`
+        - `tag`
+    - Fields that aren't searched by default, but can be included in queries with syntax like (`plot:whatever`):
+        - `plot`
+        - `library_name`
+        - `type` (`movie` or `show`)
+    - Add letter bar to all paged search results to quickly navigate to a particular letter
+
+## [0.0.20-prealpha] - 2021-03-17
+- Fix NVIDIA hardware acceleration in `develop-nvidia` and `latest-nvidia` Docker tags
+    - This may never have worked correctly in Docker with older releases
+- Fix occasional crash rebuilding playout from ui
+- Fix crash adding a channel when no channels exist
+- Fix playback for media containing attached pictures
+
+## [0.0.19-prealpha] - 2021-03-16
+- Regularly scan Plex libraries (same as local libraries)
+- Add ability to create new collection from `Add to Collection` dialog
+- Fix channel logos in XMLTV
+- Add episode posters (show posters) to XMLTV
+- Fix shuffled schedules from occasionally having repeated items when reshuffling
+    - This was more likely to happen with low-cardinality collections like A B C C A B B C A
+- Add optional FFmpeg troubleshooting reports
+- Allow synchronizing hidden Plex libraries
+
+## [0.0.18-prealpha] - 2021-03-14
+- Plex is now a supported media source
+    - Plex is **not** used for transcoding at this point, files are played directly from the filesystem using ErsatzTV transcoding
+    - Path replacements will be needed if your shared media folders are mounted differently in Plex and ErsatzTV
+
+## [0.0.17-prealpha] - 2021-03-13
+- Fix bug introduced with 0.0.16 that prevented some playouts from building
+- Properly set sort title on added tv shows
+- Fix loading season pages containing episodes that have incomplete metadata
+- Improve XMLTV guide data
+
+## [0.0.16-prealpha] - 2021-03-12
+- Fix infinite loop caused by incorrectly configured ffprobe path
+- Add more strict ffmpeg and ffprobe settings validation
+- Add custom playback order option to collections that contain only movies
+    - This custom playback order will override the schedule's configured playback order for the collection
+
+## [0.0.15-prealpha] - 2021-03-11
+- Update UI for tv shows
+- Fix tv show sorting
+- Fix editing channel numbers
+- Fix playout timezone bugs
+- Add searchable genres and tags from local NFO metadata
+- Add multi-select feature to movies, shows, search results and collection items pages
+
+## [0.0.14-prealpha] - 2021-03-09
+- New movie layout utilizing fan art (if available)
+- New dark UI
+- Fix offline stream (displayed when no media is scheduled for playback)
+- Add M3U codec hints for Channels DVR
+- Allow sub-channel numbers
+- Fix bug where ffmpeg wouldn't terminate after a media item completed playback
+- Fix time zone in new docker base images
+- Fix vaapi pipeline with mpeg4 content by using software decoder with hardware encoder
+- Enforce unique schedule name
+- Enforce unique channel number
+- Fix sorting of collection items in UI
+
+## [0.0.13-prealpha] - 2021-03-07
+- Remember selected Collection in `Add To Collection` dialog
+- Automatically rebuild Playouts referencing any Collection that has items added or removed from the UI
+- Remove Media Items from database when files are removed from disk
+- Add hardware-accelerated transcoding support (`qsv`, `nvenc`/`nvidia`, `vaapi`)
+    - All flavors support resolution normalization (scaling and padding)
+    - This requires support within ffmpeg; see README for new docker image tags
+
+## [0.0.12-prealpha] - 2021-03-02
+- Fix a database migration issue introduced with version 0.0.11
+- Shutdown app when database migration failures are encountered at startup
+
+## [0.0.11-prealpha] - 2021-03-01
+- Add Libraries and Library Paths under Media Sources
+    - Two local libraries exist: `Movies` and `Shows`
+    - Local Media Sources from prior versions are now found under Library Paths
+- Add `Rebuild Playout` buttons to quickly regenerate playouts after modifying collections
+- Add `Add to Collection` buttons to most media cards (movies, shows, seasons, episodes)
+- Add Search page for searching movies and shows
+
+## [0.0.10-prealpha] - 2021-02-21
+- Rework how television media is stored in the database
+- Rework how media is linked to a collection
+- Add season, episode and movie detail views to UI
+- Add media to collections and schedules from detail views
+- Easily add and remove media from a collection
+- Easily add and reorder schedule items
+
+## [0.0.9-prealpha] - 2021-02-15
+- Local media scanner has been rewritten and is much more performant
+- Ignore extras in the same folder as movies (`-behindthescenes`, `-trailer`, etc)
+- Support `movie.nfo` metadata in addition to matching filename nfo metadata
+- Changes to video files, metadata and posters are automatically detected and used
+
+## [0.0.8-prealpha] - 2021-02-14
+- Optimize scanning so playouts are only rebuilt when necessary (duration changes, or collection membership changes)
+- Automatically add new posters during scanning
+- Support more poster file types (jpg, jpeg, png, gif, tbn)
+- Add "Refresh All Metadata" button to media sources page; this should only be needed if NFO metadata or posters are modified
+- Add progress indicator for media sources that are being actively scanned
+- Prevent deleting media source during scan
+- Prevent creating playout with empty schedule
+
+## [0.0.7-prealpha] - 2021-02-13
+- Rework media items layout - table has been replaced with cards/posters
+- Fix bug preventing long folder names from being used as media sources
+- Use 24h time pickers in schedule editor
+
+## [0.0.6-prealpha] - 2021-02-12
+- Add version information to UI
+- Add basic log viewer to UI
+
+## [0.0.5-prealpha] - 2021-02-12
+- Fix bug where media scanner could stop prematurely and miss media items
+- Add database migrations
+
+## [0.0.4-prealpha] - 2021-02-11
+- **Fix HDHomeRun routes** - this version is required to use as a DVR with Plex, older versions will not work
+- Improve metadata parsing for tv, add fallback (filename) parsing for movies
+
+## [0.0.3-prealpha] - 2021-02-11
+- Fix incomplete XML issue introduced with v0.0.2-prealpha
+- Add `.ts` files to local media scanner
+- Change M3U, XMLTV, API icons to text links
+
+## 0.0.2-prealpha - 2021-02-11 [YANKED]
+- Relax some searches to be case-insensitive
+- Improve categorization of tv episodes without sidecar metadata
+- Properly escape XML content in XMLTV
+
+## [0.0.1-prealpha] - 2021-02-10
+- Initial release to facilitate testing outside of Docker.
+
+
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.44-prealpha...HEAD
+[0.0.43-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.43-prealpha...v0.0.44-prealpha
+[0.0.43-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.42-prealpha...v0.0.43-prealpha
+[0.0.42-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.41-prealpha...v0.0.42-prealpha
+[0.0.41-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.40-prealpha...v0.0.41-prealpha
+[0.0.40-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.39-prealpha...v0.0.40-prealpha
+[0.0.39-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.38-prealpha...v0.0.39-prealpha
+[0.0.38-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.37-prealpha...v0.0.38-prealpha
+[0.0.37-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.36-prealpha...v0.0.37-prealpha
+[0.0.36-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.35-prealpha...v0.0.36-prealpha
+[0.0.35-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.34-prealpha...v0.0.35-prealpha
+[0.0.34-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.33-prealpha...v0.0.34-prealpha
+[0.0.33-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.32-prealpha...v0.0.33-prealpha
+[0.0.32-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.31-prealpha...v0.0.32-prealpha
+[0.0.31-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.29-prealpha...v0.0.31-prealpha
+[0.0.29-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.28-prealpha...v0.0.29-prealpha
+[0.0.28-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.27-prealpha...v0.0.28-prealpha
+[0.0.27-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.26-prealpha...v0.0.27-prealpha
+[0.0.26-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.25-prealpha...v0.0.26-prealpha
+[0.0.25-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.24-prealpha...v0.0.25-prealpha
+[0.0.24-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.23-prealpha...v0.0.24-prealpha
+[0.0.23-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.22-prealpha...v0.0.23-prealpha
+[0.0.22-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.21-prealpha...v0.0.22-prealpha
+[0.0.21-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.20-prealpha...v0.0.21-prealpha
+[0.0.20-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.19-prealpha...v0.0.20-prealpha
+[0.0.19-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.18-prealpha...v0.0.19-prealpha
+[0.0.18-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.17-prealpha...v0.0.18-prealpha
+[0.0.17-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.16-prealpha...v0.0.17-prealpha
+[0.0.16-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.15-prealpha...v0.0.16-prealpha
+[0.0.15-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.14-prealpha...v0.0.15-prealpha
+[0.0.14-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.13-prealpha...v0.0.14-prealpha
+[0.0.13-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.12-prealpha...v0.0.13-prealpha
+[0.0.12-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.11-prealpha...v0.0.12-prealpha
+[0.0.11-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.10-prealpha...v0.0.11-prealpha
+[0.0.10-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.9-prealpha...v0.0.10-prealpha
+[0.0.9-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.8-prealpha...v0.0.9-prealpha
+[0.0.8-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.7-prealpha...v0.0.8-prealpha
+[0.0.7-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.6-prealpha...v0.0.7-prealpha
+[0.0.6-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.5-prealpha...v0.0.6-prealpha
+[0.0.5-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.4-prealpha...v0.0.5-prealpha
+[0.0.4-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.3-prealpha...v0.0.4-prealpha
+[0.0.3-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.1-prealpha...v0.0.3-prealpha
+[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using ErsatzTV.Application.MediaItems;
+using MediatR;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public record GetAllArtists : IRequest<List<NamedMediaItemViewModel>>;
+}

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaItems.Mapper;
+
+namespace ErsatzTV.Application.Artists.Queries
+{
+    public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+    {
+        private readonly IArtistRepository _artistRepository;
+
+        public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+
+        public Task<List<NamedMediaItemViewModel>> Handle(
+            GetAllArtists request,
+            CancellationToken cancellationToken) =>
+            _artistRepository.GetAllArtists().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

@@ -3,5 +3,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.Channels.Queries
 {
-    public record GetChannelPlaylist(string Scheme, string Host) : IRequest<ChannelPlaylist>;
+    public record GetChannelPlaylist(string Scheme, string Host, string Mode) : IRequest<ChannelPlaylist>;
 }

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -1,5 +1,7 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
 using LanguageExt;
@@ -16,6 +18,31 @@ namespace ErsatzTV.Application.Channels.Queries
 
         public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
             _channelRepository.GetAll()
+                .Map(channels => EnsureMode(channels, request.Mode))
                 .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
+
+        private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
+        {
+            var result = new List<Channel>();
+            foreach (Channel channel in channels)
+            {
+                switch (mode.ToLowerInvariant())
+                {
+                    case "hls-direct":
+                        channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
+                        result.Add(channel);
+                        break;
+                    case "ts":
+                        channel.StreamingMode = StreamingMode.TransportStream;
+                        result.Add(channel);
+                        break;
+                    default:
+                        result.Add(channel);
+                        break;
+                }
+            }
+
+            return result;
+        }
     }
 }

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class DisconnectEmbyHandler : MediatR.IRequestHandler<DisconnectEmby, Either<BaseError, Unit>>
+    {
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public DisconnectEmbyHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEntityLocker entityLocker,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DisconnectEmby request,
+            CancellationToken cancellationToken)
+        {
+            List<int> ids = await _mediaSourceRepository.DeleteAllEmby();
+            await _searchIndex.RemoveItems(ids);
+            _searchIndex.Commit();
+            await _embySecretStore.DeleteAll();
+            _entityLocker.UnlockRemoteMediaSource<EmbyMediaSource>();
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SaveEmbySecretsHandler(
+            IEmbySecretStore embySecretStore,
+            IEmbyApiClient embyApiClient,
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        {
+            _embySecretStore = embySecretStore;
+            _embyApiClient = embyApiClient;
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(SaveEmbySecrets request, CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(PerformSave)
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Validation<BaseError, Parameters>> Validate(SaveEmbySecrets request)
+        {
+            Either<BaseError, EmbyServerInformation> maybeServerInformation = await _embyApiClient
+                .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+
+            return maybeServerInformation.Match(
+                info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
+                error => error);
+        }
+
+        private async Task<Unit> PerformSave(Parameters parameters)
+        {
+            await _embySecretStore.SaveSecrets(parameters.Secrets);
+            await _mediaSourceRepository.UpsertEmby(
+                parameters.Secrets.Address,
+                parameters.ServerInformation.ServerName,
+                parameters.ServerInformation.OperatingSystem);
+            await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
+
+            return Unit.Default;
+        }
+
+        private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+        IEmbyBackgroundServiceRequest;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -0,0 +1,118 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class
+        SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
+    {
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public SynchronizeEmbyLibrariesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEmbyApiClient embyApiClient,
+            ILogger<SynchronizeEmbyLibrariesHandler> logger,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _embyApiClient = embyApiClient;
+            _logger = logger;
+            _searchIndex = searchIndex;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            SynchronizeEmbyLibraries request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(SynchronizeLibraries)
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
+            MediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
+            SynchronizeEmbyLibraries request) =>
+            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+                .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Emby media source requires an api key");
+        }
+
+        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+        {
+            Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
+                connectionParameters.ActiveConnection.Address,
+                connectionParameters.ApiKey);
+
+            await maybeLibraries.Match(
+                async libraries =>
+                {
+                    var existing = connectionParameters.EmbyMediaSource.Libraries.OfType<EmbyLibrary>()
+                        .ToList();
+                    var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
+                    var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
+                    List<int> ids = await _mediaSourceRepository.UpdateLibraries(
+                        connectionParameters.EmbyMediaSource.Id,
+                        toAdd,
+                        toRemove);
+                    if (ids.Any())
+                    {
+                        await _searchIndex.RemoveItems(ids);
+                        _searchIndex.Commit();
+                    }
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Unable to synchronize libraries from emby server {EmbyServer}: {Error}",
+                        connectionParameters.EmbyMediaSource.ServerName,
+                        error.Value);
+
+                    return Task.CompletedTask;
+                });
+
+            return Unit.Default;
+        }
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

@@ -0,0 +1,23 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
+        IEmbyBackgroundServiceRequest
+    {
+        int EmbyLibraryId { get; }
+        bool ForceScan { get; }
+    }
+
+    public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+    {
+        public bool ForceScan => false;
+    }
+
+    public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+    {
+        public bool ForceScan => true;
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -0,0 +1,172 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SynchronizeEmbyLibraryByIdHandler :
+        IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+        IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
+
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
+        private readonly IEntityLocker _entityLocker;
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
+
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyLibraryByIdHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEmbyMovieLibraryScanner embyMovieLibraryScanner,
+            IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
+            ILibraryRepository libraryRepository,
+            IEntityLocker entityLocker,
+            IConfigElementRepository configElementRepository,
+            ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _embyMovieLibraryScanner = embyMovieLibraryScanner;
+            _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
+            _libraryRepository = libraryRepository;
+            _entityLocker = entityLocker;
+            _configElementRepository = configElementRepository;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, string>> Handle(
+            ForceSynchronizeEmbyLibraryById request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        public Task<Either<BaseError, string>> Handle(
+            SynchronizeEmbyLibraryByIdIfNeeded request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        private Task<Either<BaseError, string>>
+            Handle(ISynchronizeEmbyLibraryById request) =>
+            Validate(request)
+                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> Synchronize(RequestParameters parameters)
+        {
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            if (parameters.ForceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
+            {
+                switch (parameters.Library.MediaKind)
+                {
+                    case LibraryMediaKind.Movies:
+                        await _embyMovieLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                    case LibraryMediaKind.Shows:
+                        await _embyTelevisionLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                }
+
+                parameters.Library.LastScan = DateTime.UtcNow;
+                await _libraryRepository.UpdateLastScan(parameters.Library);
+            }
+            else
+            {
+                _logger.LogDebug(
+                    "Skipping unforced scan of emby media library {Name}",
+                    parameters.Library.Name);
+            }
+
+            _entityLocker.UnlockLibrary(parameters.Library.Id);
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, RequestParameters>> Validate(
+            ISynchronizeEmbyLibraryById request) =>
+            (await ValidateConnection(request), await EmbyLibraryMustExist(request), await ValidateFFprobePath())
+            .Apply(
+                (connectionParameters, embyLibrary, ffprobePath) => new RequestParameters(
+                    connectionParameters,
+                    embyLibrary,
+                    request.ForceScan,
+                    ffprobePath
+                ));
+
+        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+            ISynchronizeEmbyLibraryById request) =>
+            EmbyMediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Emby media source for library {request.EmbyLibraryId} does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Emby media source requires an api key");
+        }
+
+        private Task<Validation<BaseError, EmbyLibrary>> EmbyLibraryMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
+                .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
+
+        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+                .FilterT(File.Exists)
+                .Map(
+                    ffprobePath =>
+                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+        private record RequestParameters(
+            ConnectionParameters ConnectionParameters,
+            EmbyLibrary Library,
+            bool ForceScan,
+            string FFprobePath);
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
+        Either<BaseError, List<EmbyMediaSource>>>
+    {
+        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyMediaSourcesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
+            SynchronizeEmbyMediaSources request,
+            CancellationToken cancellationToken)
+        {
+            List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
+            foreach (EmbyMediaSource mediaSource in mediaSources)
+            {
+                // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
+                await _channel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
+            }
+
+            return mediaSources;
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record UpdateEmbyPathReplacements(
+        int EmbyMediaSourceId,
+        List<EmbyPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record EmbyPathReplacementItem(int Id, string EmbyPath, string LocalPath);
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

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

ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyConnectionParametersViewModel(string Address);
+}

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

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

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Application.MediaSources;
+
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
+        Id,
+        Name,
+        Address);
+}

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyPathReplacementViewModel(int Id, string EmbyPath, string LocalPath);
+}

ErsatzTV.Application/Emby/Mapper.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Emby
+{
+    internal static class Mapper
+    {
+        internal static EmbyMediaSourceViewModel ProjectToViewModel(EmbyMediaSource embyMediaSource) =>
+            new(
+                embyMediaSource.Id,
+                embyMediaSource.ServerName,
+                embyMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
+
+        internal static EmbyLibraryViewModel ProjectToViewModel(EmbyLibrary library) =>
+            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+
+        internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
+            new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSources, List<EmbyMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetAllEmbyMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyMediaSourceViewModel>> Handle(
+            GetAllEmbyMediaSources request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+        Either<BaseError, EmbyConnectionParametersViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
+
+        public GetEmbyConnectionParametersHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository)
+        {
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
+
+        public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
+            GetEmbyConnectionParameters request,
+            CancellationToken cancellationToken)
+        {
+            if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
+            {
+                return parameters;
+            }
+
+            Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
+                await Validate()
+                    .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                    .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
+
+            return maybeParameters.Match(
+                p =>
+                {
+                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                    return maybeParameters;
+                },
+                error => error);
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+            EmbyMediaSourceMustExist()
+                .BindT(MediaSourceMustHaveActiveConnection);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+            _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        "Emby media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class
+        GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyLibraryViewModel>> Handle(
+            GetEmbyLibrariesBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class
+        GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<Option<EmbyMediaSourceViewModel>> Handle(
+            GetEmbyMediaSourceById request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyPathReplacementsBySourceId
+        (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
+        List<EmbyPathReplacementViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyPathReplacementViewModel>> Handle(
+            GetEmbyPathReplacementsBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs

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

ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
+    {
+        private readonly IEmbySecretStore _embySecretStore;
+
+        public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
+            _embySecretStore = embySecretStore;
+
+        public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
+            _embySecretStore.ReadSecrets();
+    }
+}

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -3,6 +3,7 @@
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
+        <DebugType>embedded</DebugType>
     </PropertyGroup>
 
     <ItemGroup>
@@ -16,7 +17,7 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>
 

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,11 +1,13 @@
 using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
 using LanguageExt;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
@@ -14,13 +16,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly ILocalFileSystem _localFileSystem;
+        private readonly IRuntimeInfo _runtimeInfo;
 
         public UpdateFFmpegSettingsHandler(
             IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem)
+            ILocalFileSystem localFileSystem,
+            IRuntimeInfo runtimeInfo)
         {
             _configElementRepository = configElementRepository;
             _localFileSystem = localFileSystem;
+            _runtimeInfo = runtimeInfo;
         }
 
         public Task<Either<BaseError, Unit>> Handle(
@@ -31,8 +36,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(v => v.ToEitherAsync());
 
         private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
-            (await FFmpegMustExist(request), await FFprobeMustExist(request))
-            .Apply((_, _) => Unit.Default);
+            (await FFmpegMustExist(request), await FFprobeMustExist(request), ReportsAreNotSupportedOnWindows(request))
+            .Apply((_, _, _) => Unit.Default);
 
         private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
@@ -40,6 +45,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
 
+        private Validation<BaseError, Unit> ReportsAreNotSupportedOnWindows(UpdateFFmpegSettings request)
+        {
+            if (request.Settings.SaveReports && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+            {
+                return BaseError.New("FFmpeg reports are not supported on Windows");
+            }
+
+            return Unit.Default;
+        }
+
         private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
         {
             if (!_localFileSystem.FileExists(path))

ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs

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

ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs

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

ErsatzTV.Application/Images/CachedImagePathViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Images
+{
+    public record CachedImagePathViewModel(string FileName, string MimeType);
+}

ErsatzTV.Application/Images/ImageViewModel.cs

@@ -1,5 +0,0 @@
-namespace ErsatzTV.Application.Images
-{
-    // ReSharper disable once SuggestBaseTypeForParameter
-    public record ImageViewModel(byte[] Contents, string MimeType);
-}

ErsatzTV.Application/Images/Queries/GetCachedImagePath.cs

@@ -5,6 +5,7 @@ using MediatR;
 
 namespace ErsatzTV.Application.Images.Queries
 {
-    public record GetImageContents
-        (string FileName, ArtworkKind ArtworkKind, int? MaxHeight = null) : IRequest<Either<BaseError, ImageViewModel>>;
+    public record GetCachedImagePath
+        (string FileName, ArtworkKind ArtworkKind, int? MaxHeight = null) : IRequest<
+            Either<BaseError, CachedImagePathViewModel>>;
 }

ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Images;
+using LanguageExt;
+using MediatR;
+using Winista.Mime;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Images.Queries
+{
+    public class
+        GetCachedImagePathHandler : IRequestHandler<GetCachedImagePath, Either<BaseError, CachedImagePathViewModel>>
+    {
+        private static readonly MimeTypes MimeTypes = new();
+        private readonly IImageCache _imageCache;
+
+        public GetCachedImagePathHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+        public async Task<Either<BaseError, CachedImagePathViewModel>> Handle(
+            GetCachedImagePath request,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                MimeType mimeType;
+
+                string cachePath = _imageCache.GetPathForImage(
+                    request.FileName,
+                    request.ArtworkKind,
+                    Optional(request.MaxHeight));
+                if (!File.Exists(cachePath))
+                {
+                    if (request.MaxHeight.HasValue)
+                    {
+                        string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
+                        byte[] contents = await File.ReadAllBytesAsync(originalPath, cancellationToken);
+                        Either<BaseError, byte[]> resizeResult =
+                            await _imageCache.ResizeImage(contents, request.MaxHeight.Value);
+                        resizeResult.IfRight(result => contents = result);
+
+                        string baseFolder = Path.GetDirectoryName(cachePath);
+                        if (baseFolder != null && !Directory.Exists(baseFolder))
+                        {
+                            Directory.CreateDirectory(baseFolder);
+                        }
+
+                        await File.WriteAllBytesAsync(cachePath, contents, cancellationToken);
+
+                        mimeType = new MimeType("image/jpeg");
+                    }
+                    else
+                    {
+                        return BaseError.New($"Artwork does not exist on disk at {cachePath}");
+                    }
+                }
+                else
+                {
+                    mimeType = MimeTypes.GetMimeTypeFromFile(cachePath);
+                }
+
+                return new CachedImagePathViewModel(cachePath, mimeType.Name);
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.Message);
+            }
+        }
+    }
+}

ErsatzTV.Application/Images/Queries/GetImageContentsHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs

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

ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs

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

ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs

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

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs

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

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs

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

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs

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

ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs

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

ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Jellyfin
+{
+    public record JellyfinConnectionParametersViewModel(string Address);
+}

ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs

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

ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs

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

ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs

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

ErsatzTV.Application/Jellyfin/Mapper.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class
+        GetAllJellyfinMediaSourcesHandler : IRequestHandler<GetAllJellyfinMediaSources,
+            List<JellyfinMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetAllJellyfinMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinMediaSourceViewModel>> Handle(
+            GetAllJellyfinMediaSources request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetAllJellyfin().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinConnectionParameters : IRequest<Either<BaseError, JellyfinConnectionParametersViewModel>>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class GetJellyfinConnectionParametersHandler : IRequestHandler<GetJellyfinConnectionParameters,
+        Either<BaseError, JellyfinConnectionParametersViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
+
+        public GetJellyfinConnectionParametersHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository)
+        {
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
+
+        public async Task<Either<BaseError, JellyfinConnectionParametersViewModel>> Handle(
+            GetJellyfinConnectionParameters request,
+            CancellationToken cancellationToken)
+        {
+            if (_memoryCache.TryGetValue(request, out JellyfinConnectionParametersViewModel parameters))
+            {
+                return parameters;
+            }
+
+            Either<BaseError, JellyfinConnectionParametersViewModel> maybeParameters =
+                await Validate()
+                    .MapT(cp => new JellyfinConnectionParametersViewModel(cp.ActiveConnection.Address))
+                    .Map(v => v.ToEither<JellyfinConnectionParametersViewModel>());
+
+            return maybeParameters.Match(
+                p =>
+                {
+                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                    return maybeParameters;
+                },
+                error => error);
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+            JellyfinMediaSourceMustExist()
+                .BindT(MediaSourceMustHaveActiveConnection);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist() =>
+            _mediaSourceRepository.GetAllJellyfin().Map(list => list.HeadOrNone())
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        "Jellyfin media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.FirstOrDefault();
+            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+        }
+
+        private record ConnectionParameters(
+            JellyfinMediaSource JellyfinMediaSource,
+            JellyfinConnection ActiveConnection);
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class
+        GetJellyfinLibrariesBySourceIdHandler : IRequestHandler<GetJellyfinLibrariesBySourceId,
+            List<JellyfinLibraryViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetJellyfinLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinLibraryViewModel>> Handle(
+            GetJellyfinLibrariesBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetJellyfinLibraries(request.JellyfinMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Jellyfin.Mapper;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class GetJellyfinPathReplacementsBySourceIdHandler : IRequestHandler<GetJellyfinPathReplacementsBySourceId,
+        List<JellyfinPathReplacementViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetJellyfinPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<JellyfinPathReplacementViewModel>> Handle(
+            GetJellyfinPathReplacementsBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetJellyfinPathReplacements(request.JellyfinMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs

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

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs

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

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

@@ -32,6 +32,7 @@ namespace ErsatzTV.Application.Libraries.Commands
         {
             List<int> ids = await _libraryRepository.GetMediaIdsByLocalPath(libraryPath.Id);
             await _searchIndex.RemoveItems(ids);
+            _searchIndex.Commit();
             await _libraryRepository.DeleteLocalPath(libraryPath.Id);
             return Unit.Default;
         }

ErsatzTV.Application/Libraries/Mapper.cs

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

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -21,6 +21,7 @@ namespace ErsatzTV.Application.Libraries.Queries
                 .Map(
                     list => list.Filter(ShouldIncludeLibrary)
                         .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
+                        .ThenBy(l => l.GetType().Name)
                         .ThenBy(l => l.MediaKind)
                         .Map(ProjectToViewModel).ToList());
 
@@ -29,6 +30,8 @@ namespace ErsatzTV.Application.Libraries.Queries
             {
                 LocalLibrary => true,
                 PlexLibrary plex => plex.ShouldSyncItems,
+                JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+                EmbyLibrary emby => emby.ShouldSyncItems,
                 _ => false
             };
     }

ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtwork.cs

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

ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtworkHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Maintenance.Commands
+{
+    public class DeleteOrphanedArtworkHandler : MediatR.IRequestHandler<DeleteOrphanedArtwork, Either<BaseError, Unit>>
+    {
+        private readonly IArtworkRepository _artworkRepository;
+
+        public DeleteOrphanedArtworkHandler(IArtworkRepository artworkRepository) =>
+            _artworkRepository = artworkRepository;
+
+        public Task<Either<BaseError, Unit>>
+            Handle(DeleteOrphanedArtwork request, CancellationToken cancellationToken) =>
+            _artworkRepository.GetOrphanedArtwork()
+                .Bind(_artworkRepository.Delete)
+                .Map(_ => Right<BaseError, Unit>(Unit.Default));
+    }
+}

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -1,21 +1,30 @@
 using System;
 using System.Linq;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Jellyfin;
+using LanguageExt;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.MediaCards
 {
     internal static class Mapper
     {
-        internal static TelevisionShowCardViewModel ProjectToViewModel(ShowMetadata showMetadata) =>
+        internal static TelevisionShowCardViewModel ProjectToViewModel(
+            ShowMetadata showMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 showMetadata.ShowId,
                 showMetadata.Title,
                 showMetadata.Year?.ToString(),
                 showMetadata.SortTitle,
-                GetPoster(showMetadata));
+                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
 
-        internal static TelevisionSeasonCardViewModel ProjectToViewModel(Season season) =>
+        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+            Season season,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
                 season.Id,
@@ -23,11 +32,15 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(season.SeasonNumber),
                 string.Empty,
                 GetSeasonName(season.SeasonNumber),
-                season.SeasonMetadata.HeadOrNone().Map(GetPoster).IfNone(string.Empty),
+                season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
+                    .IfNone(string.Empty),
                 season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
 
         internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
-            EpisodeMetadata episodeMetadata) =>
+            EpisodeMetadata episodeMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby,
+            bool isSearchResult) =>
             new(
                 episodeMetadata.EpisodeId,
                 episodeMetadata.ReleaseDate ?? DateTime.MinValue,
@@ -36,20 +49,29 @@ namespace ErsatzTV.Application.MediaCards
                     () => string.Empty),
                 episodeMetadata.Episode.Season.ShowId,
                 episodeMetadata.Episode.SeasonId,
-                episodeMetadata.Episode.EpisodeNumber,
+                episodeMetadata.Episode.Season.SeasonNumber,
+                episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, () => 0),
                 episodeMetadata.Title,
+                episodeMetadata.SortTitle,
                 episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
                     em => em.Plot ?? string.Empty,
                     () => string.Empty),
-                GetThumbnail(episodeMetadata));
+                isSearchResult
+                    ? GetEpisodePoster(episodeMetadata, maybeJellyfin, maybeEmby)
+                    : GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby),
+                episodeMetadata.Directors.Map(d => d.Name).ToList(),
+                episodeMetadata.Writers.Map(w => w.Name).ToList());
 
-        internal static MovieCardViewModel ProjectToViewModel(MovieMetadata movieMetadata) =>
+        internal static MovieCardViewModel ProjectToViewModel(
+            MovieMetadata movieMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 movieMetadata.MovieId,
                 movieMetadata.Title,
                 movieMetadata.Year?.ToString(),
                 movieMetadata.SortTitle,
-                GetPoster(movieMetadata));
+                GetPoster(movieMetadata, maybeJellyfin, maybeEmby));
 
         internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
             new(
@@ -58,7 +80,7 @@ namespace ErsatzTV.Application.MediaCards
                 musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
                 musicVideoMetadata.SortTitle,
                 musicVideoMetadata.Plot,
-                GetThumbnail(musicVideoMetadata));
+                GetThumbnail(musicVideoMetadata, None, None));
 
         internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
             new(
@@ -66,27 +88,52 @@ namespace ErsatzTV.Application.MediaCards
                 artistMetadata.Title,
                 artistMetadata.Disambiguation,
                 artistMetadata.SortTitle,
-                GetThumbnail(artistMetadata));
+                GetThumbnail(artistMetadata, None, None));
 
         internal static CollectionCardResultsViewModel
-            ProjectToViewModel(Collection collection) =>
+            ProjectToViewModel(
+                Collection collection,
+                Option<JellyfinMediaSource> maybeJellyfin,
+                Option<EmbyMediaSource> maybeEmby) =>
             new(
                 collection.Name,
                 collection.MediaItems.OfType<Movie>().Map(
-                    m => ProjectToViewModel(m.MovieMetadata.Head()) with
+                    m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin, maybeEmby) with
                     {
                         CustomIndex = GetCustomIndex(collection, m.Id)
                     }).ToList(),
-                collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList(),
-                collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
-                collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
+                collection.MediaItems.OfType<Show>()
+                    .Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin, maybeEmby))
+                    .ToList(),
+                collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby))
+                    .ToList(),
+                collection.MediaItems.OfType<Episode>()
+                    .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin, maybeEmby, false))
                     .ToList(),
                 collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
-        internal static ActorCardViewModel ProjectToViewModel(Actor actor) =>
-            new(actor.Id, actor.Name, actor.Role, actor.Artwork?.Path);
+        internal static ActorCardViewModel ProjectToViewModel(
+            Actor actor,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            string artwork = actor.Artwork?.Path ?? string.Empty;
+
+            if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
+            {
+                artwork = JellyfinUrl.ForArtwork(maybeJellyfin, artwork)
+                    .SetQueryParam("fillHeight", 440);
+            }
+            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+            {
+                artwork = EmbyUrl.ForArtwork(maybeEmby, artwork)
+                    .SetQueryParam("maxHeight", 440);
+            }
+
+            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork);
+        }
 
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>
             Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
@@ -96,12 +143,66 @@ namespace ErsatzTV.Application.MediaCards
         private static string GetSeasonName(int number) =>
             number == 0 ? "Specials" : $"Season {number}";
 
-        private static string GetPoster(Metadata metadata) =>
-            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
+        private static string GetEpisodePoster(
+            EpisodeMetadata episodeMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            Option<SeasonMetadata> maybeSeasonMetadata = episodeMetadata.Episode.Season.SeasonMetadata.HeadOrNone();
+            return maybeSeasonMetadata.Match(
+                seasonMetadata => GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
+                () =>
+                {
+                    Option<ShowMetadata> maybeShowMetadata =
+                        episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone();
+                    return maybeShowMetadata.Match(
+                        showMetadata => GetPoster(showMetadata, maybeJellyfin, maybeEmby),
+                        () => string.Empty);
+                });
+        }
+
+        private static string GetPoster(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            string poster = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
                 .Match(a => a.Path, string.Empty);
 
-        private static string GetThumbnail(Metadata metadata) =>
-            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
+            if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
+            {
+                poster = JellyfinUrl.ForArtwork(maybeJellyfin, poster)
+                    .SetQueryParam("fillHeight", 440);
+            }
+            else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
+            {
+                poster = EmbyUrl.ForArtwork(maybeEmby, poster)
+                    .SetQueryParam("maxHeight", 440);
+            }
+
+            return poster;
+        }
+
+        private static string GetThumbnail(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            string thumb = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
                 .Match(a => a.Path, string.Empty);
+
+            if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
+            {
+                thumb = JellyfinUrl.ForArtwork(maybeJellyfin, thumb)
+                    .SetQueryParam("fillHeight", 220);
+            }
+            else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
+            {
+                thumb = EmbyUrl.ForArtwork(maybeEmby, thumb)
+                    .SetQueryParam("maxHeight", 220);
+            }
+
+            return thumb;
+        }
     }
 }

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

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

ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs

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

ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs

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

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs

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

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace ErsatzTV.Application.MediaCards
 {
@@ -9,15 +10,17 @@ namespace ErsatzTV.Application.MediaCards
         string ShowTitle,
         int ShowId,
         int SeasonId,
+        int Season,
         int Episode,
         string Title,
+        string SortTitle,
         string Plot,
-        string Poster) : MediaCardViewModel(
+        string Poster,
+        List<string> Directors,
+        List<string> Writers) : MediaCardViewModel(
         EpisodeId,
         Title,
         $"Episode {Episode}",
-        $"Episode {Episode}",
-        Poster)
-    {
-    }
+        SortTitle,
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -14,7 +14,5 @@
         Title,
         Subtitle,
         SortTitle,
-        Poster)
-    {
-    }
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -6,7 +6,5 @@
             Title,
             Subtitle,
             SortTitle,
-            Poster)
-    {
-    }
+            Poster);
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -9,6 +9,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         int CollectionId,
         List<int> MovieIds,
         List<int> ShowIds,
+        List<int> EpisodeIds,
         List<int> ArtistIds,
         List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }