update changelog for release v0.7.4-beta [no ci]

* sync episode tags and genres

* update dependencies

* property update local episode genres and tags

* fix test

.config/dotnet-tools.json

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

.editorconfig

@@ -1,6 +1,6 @@
 
 [*]
-charset=utf-8-bom
+charset=utf-8
 end_of_line=lf
 trim_trailing_whitespace=false
 insert_final_newline=false

.github/dependabot.yml

@@ -6,3 +6,21 @@ updates:
       interval: daily
     assignees:
       - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker/nvidia"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker/vaapi"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove

.github/workflows/artifacts.yml

@@ -0,0 +1,271 @@
+name: Build Artifacts
+on:
+  workflow_call:
+    inputs:
+      release_tag:
+        description: 'Release tag'
+        required: true
+        type: string
+      release_version:
+        description: 'Release version number (e.g. v0.3.7-alpha)'
+        required: true
+        type: string
+      info_version:
+        description: 'Informational version number (e.g. 0.3.7-alpha)'
+        required: true
+        type: string
+    secrets:
+      apple_developer_certificate_p12_base64:
+        required: true
+      apple_developer_certificate_password:
+        required: true
+      ac_username:
+        required: true
+      ac_password:
+        required: true
+      gh_token:
+        required: true
+jobs:
+  build_and_upload_mac:
+    name: Mac Build & Upload
+    runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
+    strategy:
+      matrix:
+        include:
+          - os: macos-11
+            kind: macOS
+            target: osx-x64
+          - os: macos-11
+            kind: macOS
+            target: osx-arm64
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.8.28
+        with:
+          working-directory: ErsatzTV/client-app
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "${{ matrix.target}}"
+
+      - name: Import Code-Signing Certificates
+        uses: Apple-Actions/import-codesign-certs@v1
+        with:
+          p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
+          p12-password: ${{ secrets.apple_developer_certificate_password }}
+
+      - name: Calculate Release Name
+        shell: bash
+        run: |
+          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+
+      - name: Build
+        shell: bash
+        run: |
+          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+
+      - name: Bundle
+        shell: bash
+        run: |
+          brew install coreutils
+          plutil -replace CFBundleShortVersionString -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
+          plutil -replace CFBundleVersion -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
+          scripts/macOS/bundle.sh
+
+      - name: Sign
+        shell: bash
+        run: scripts/macOS/sign.sh
+      
+      - name: Create DMG
+        shell: bash
+        run: |
+          brew install create-dmg
+          create-dmg \
+            --volname "ErsatzTV" \
+            --volicon "artwork/ErsatzTV.icns" \
+            --window-pos 200 120 \
+            --window-size 800 400 \
+            --icon-size 100 \
+            --icon "ErsatzTV.app" 200 190 \
+            --hide-extension "ErsatzTV.app" \
+            --app-drop-link 600 185 \
+            --skip-jenkins \
+            "ErsatzTV.dmg" \
+            "ErsatzTV.app/"
+
+      - name: Notarize
+        shell: bash
+        run: |
+          brew tap mitchellh/gon
+          brew install mitchellh/gon/gon
+          gon -log-level=debug -log-json ./gon.json
+        env:
+          AC_USERNAME: ${{ secrets.ac_username }}
+          AC_PASSWORD: ${{ secrets.ac_password }}
+
+      - name: Cleanup
+        shell: bash
+        run: |
+          mv ErsatzTV.dmg "${{ env.RELEASE_NAME }}.dmg"
+          rm -r publish
+          rm -r ErsatzTV.app
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: |
+            *${{ matrix.target }}.dmg
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: true
+          tag_name: ${{ inputs.release_tag }}
+          files: |
+            ${{ env.RELEASE_NAME }}.dmg
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}
+  build_and_upload:
+    name: Build & Upload
+    runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-x64
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-arm64
+          - os: windows-latest
+            kind: windows
+            target: win-x64
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+        if: ${{ matrix.kind == 'windows' }}
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.8.28
+        with:
+          working-directory: ErsatzTV/client-app
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "${{ matrix.target }}"
+
+      - uses: suisei-cn/actions-download-file@v1.3.0
+        if: ${{ matrix.kind == 'windows' }}
+        id: downloadffmpeg
+        name: Download ffmpeg
+        with:
+          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.1/ffmpeg-5.1-full_build.7z"
+          target: ffmpeg/
+
+      - name: Build
+        shell: bash
+        run: |
+          # Define some variables for things we need
+          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+
+          # Build everything
+          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+
+          # Build Windows launcher
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
+            ls -l ErsatzTV-Windows/target/release
+            mv ErsatzTV-Windows/target/release/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
+          fi
+
+          # Download ffmpeg
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
+            rm -f "$release_name/ffplay.exe"
+          fi
+
+          # Pack files
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            7z a -tzip "${release_name}.zip" "./${release_name}/*"
+          else
+            tar czvf "${release_name}.tar.gz" "$release_name"
+          fi
+
+          # Delete output directory
+          rm -r "$release_name"
+        env:
+          AC_USERNAME: ${{ secrets.ac_username }}
+          AC_PASSWORD: ${{ secrets.ac_password }}
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: |
+            *${{ matrix.target }}.zip
+            *${{ matrix.target }}.tar.gz
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: true
+          tag_name: ${{ inputs.release_tag }}
+          files: |
+            ${{ env.RELEASE_NAME }}.zip
+            ${{ env.RELEASE_NAME }}.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -1,110 +1,58 @@
 name: Build
 on:
   workflow_dispatch:
-  pull_request:
   push:
     branches:
       - main
 jobs:
-  build_and_test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
+  calculate_version:
+    name: Calculate version information
+    runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --no-restore --verbosity normal
-  build_and_push:
-    name: Build & Publish to Docker Hub
-    needs: build_and_test
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no docker]')
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
-
-      - name: Extract Git Tag
+      - name: Extract Docker Tag
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           tag2="${tag:1}"
           short=$(git rev-parse --short HEAD)
-          final="${tag2/alpha/$short}"
+          final="${tag2/beta/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
-
-      - name: Set up Docker Buildx Base
-        uses: docker/setup-buildx-action@v1
-        id: builder-base
-
-      - name: Set up Docker Buildx NVIDIA
-        uses: docker/setup-buildx-action@v1
-        id: builder-nvidia
-
-      - name: Set up Docker Buildx VAAPI
-        uses: docker/setup-buildx-action@v1
-        id: builder-vaapi
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-
-      - name: Build and push base
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-base.outputs.name }}
-          context: .
-          file: ./docker/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker
-          tags: |
-            jasongdove/ersatztv:develop
-            jasongdove/ersatztv:${{ github.sha }}
-
-      - name: Build and push nvidia
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-nvidia.outputs.name }}
-          context: .
-          file: ./docker/nvidia/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
-          tags: |
-            jasongdove/ersatztv:develop-nvidia
-            jasongdove/ersatztv:${{ github.sha }}-nvidia
-
-      - name: Build and push vaapi
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-vaapi.outputs.name }}
-          context: .
-          file: ./docker/vaapi/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
-          tags: |
-            jasongdove/ersatztv:develop-vaapi
-            jasongdove/ersatztv:${{ github.sha }}-vaapi
+      - name: Extract Artifacts Version
+        shell: bash
+        run: |
+          tag=$(git describe --tags --abbrev=0)
+          short=$(git rev-parse --short HEAD)
+          final="${tag/beta/$short}"
+          echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
+          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
+    outputs:
+      git_tag: ${{ env.GIT_TAG }}
+      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
+      info_version: ${{ env.INFO_VERSION }}
+  build_and_upload:
+    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    needs: calculate_version
+    with:
+      release_tag: develop
+      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
+      info_version: ${{ needs.calculate_version.outputs.info_version }}
+    secrets:
+      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
+      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
+      ac_username: ${{ secrets.AC_USERNAME }}
+      ac_password: ${{ secrets.AC_PASSWORD }}
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
+  build_and_push:
+    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
+    needs: calculate_version
+    with:
+      base_version: develop
+      info_version: ${{ needs.calculate_version.outputs.git_tag }}
+      tag_version: ${{ github.sha }}
+    secrets:
+      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
+      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

.github/workflows/docker.yml

@@ -0,0 +1,112 @@
+name: Build & Publish to Docker Hub
+on:
+  workflow_call:
+    inputs:
+      base_version:
+        description: 'Base version (latest or develop)'
+        required: true
+        type: string
+      info_version:
+        description: 'Informational version number (e.g. 0.3.7-alpha)'
+        required: true
+        type: string
+      tag_version:
+        description: 'Docker tag version (e.g. v0.3.7)'
+        required: true
+        type: string
+    secrets:
+      docker_hub_username:
+        required: true
+      docker_hub_access_token:
+        required: true
+jobs:
+  build_and_push:
+    name: Build & Publish
+    runs-on: ubuntu-latest
+    if: contains(github.event.head_commit.message, '[no build]') == false
+    strategy:
+      matrix:
+        include:
+          - name: base
+            path: ''
+            suffix: ''
+            qemu: false
+          - name: nvidia
+            path: 'nvidia/'
+            suffix: '-nvidia'
+            qemu: false
+          - name: vaapi
+            path: 'vaapi/'
+            suffix: '-vaapi'
+            qemu: false
+          - name: arm32v7
+            path: 'arm32v7/'
+            suffix: '-arm'
+            qemu: true
+          - name: arm64
+            path: 'arm64/'
+            suffix: '-arm64'
+            qemu: true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+        if: ${{ matrix.qemu == true }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+        id: docker-buildx
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.docker_hub_username }}
+          password: ${{ secrets.docker_hub_access_token }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          platforms: 'linux/arm64'
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm64' }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          platforms: 'linux/arm/v7'
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm32v7' }}

.github/workflows/docs.yml

@@ -3,14 +3,16 @@ on:
   push:
     branches:
       - main
-
+    paths:
+      - docs/**
+      - mkdocs.yml
 jobs:
   build:
     name: Deploy docs
     runs-on: ubuntu-latest
     steps:
       - name: Checkout master
-        uses: actions/checkout@v1
+        uses: actions/checkout@v3
 
       - name: Deploy docs
         uses: mhausenblas/mkdocs-deploy-gh-pages@master

.github/workflows/pr.yml

@@ -0,0 +1,92 @@
+name: Pull Request
+on:
+  pull_request:
+jobs:
+  build_and_test_windows:
+    runs-on: windows-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+
+      - name: Build Windows
+        run: |
+          cd ErsatzTV-Windows
+          cargo build --release --all-features
+  build_and_test_linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+  build_and_test_mac:
+    runs-on: macos-11
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal

.github/workflows/release.yml

@@ -1,142 +1,53 @@
-name: Publish
+name: Release
 on:
   release:
     types: [ published ]
 jobs:
-  release:
-    name: Release
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-arm
-          - os: windows-latest
-            kind: windows
-            target: win-x64
-          - os: macos-latest
-            kind: maxOS
-            target: osx-x64
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v2
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Build
-        shell: bash
-        run: |
-          # Define some variables for things we need
-          tag=$(git describe --tags --abbrev=0)
-          release_name="ErsatzTV-$tag-${{ matrix.target }}"
-
-          # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:PublishSingleFile=true --self-contained true
-
-          # Pack files
-          if [ "${{ matrix.target }}" == "win-x64" ]; then
-            7z a -tzip "${release_name}.zip" "./${release_name}/*"
-          elif [ "${{ matrix.target }}" == "linux-arm" ]; then
-            cp lib/linux-arm/* "$release_name/"
-            tar czvf "${release_name}.tar.gz" "$release_name"
-          else
-            tar czvf "${release_name}.tar.gz" "$release_name"
-          fi
-
-          # Delete output directory
-          rm -r "$release_name"
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: true
-          files: |
-            ErsatzTV*.zip
-            ErsatzTV*.tar.gz
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  build_and_push:
-    name: Build & Publish to Docker Hub
+  calculate_version:
+    name: Calculate version information
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
+      - name: Get the sources
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
-
-      - name: Extract Git Tag
+      - name: Extract Docker Tag
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV
-
-      - name: Set up Docker Buildx Base
-        uses: docker/setup-buildx-action@v1
-        id: builder-base
-
-      - name: Set up Docker Buildx NVIDIA
-        uses: docker/setup-buildx-action@v1
-        id: builder-nvidia
-
-      - name: Set up Docker Buildx VAAPI
-        uses: docker/setup-buildx-action@v1
-        id: builder-vaapi
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-
-      - name: Build and push base
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-base.outputs.name }}
-          context: .
-          file: ./docker/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker
-          tags: |
-            jasongdove/ersatztv:latest
-            jasongdove/ersatztv:${{ env.DOCKER_TAG }}
-
-      - name: Build and push nvidia
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-nvidia.outputs.name }}
-          context: .
-          file: ./docker/nvidia/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
-          tags: |
-            jasongdove/ersatztv:latest-nvidia
-            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-nvidia
-
-      - name: Build and push vaapi
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-vaapi.outputs.name }}
-          context: .
-          file: ./docker/vaapi/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
-          tags: |
-            jasongdove/ersatztv:latest-vaapi
-            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-vaapi
+          echo "DOCKER_TAG=${tag/-beta/}" >> $GITHUB_ENV
+      - name: Extract Artifacts Version
+        shell: bash
+        run: |
+          tag=$(git describe --tags --abbrev=0)
+          echo "ARTIFACTS_VERSION=${tag}" >> $GITHUB_ENV
+          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
+    outputs:
+      git_tag: ${{ env.GIT_TAG }}
+      docker_tag: ${{ env.DOCKER_TAG }}
+      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
+      info_version: ${{ env.INFO_VERSION }}
+  build_and_upload:
+    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    needs: calculate_version
+    with:
+      release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
+      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
+      info_version: ${{ needs.calculate_version.outputs.info_version }}
+    secrets:
+      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
+      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
+      ac_username: ${{ secrets.AC_USERNAME }}
+      ac_password: ${{ secrets.AC_PASSWORD }}
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
+  build_and_push:
+    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
+    needs: calculate_version
+    with:
+      base_version: latest
+      info_version: ${{ needs.calculate_version.outputs.git_tag }}
+      tag_version: ${{ needs.calculate_version.outputs.docker_tag }}
+    secrets:
+      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
+      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

.github/workflows/vue-lint.yml

@@ -0,0 +1,22 @@
+name: Lint VueJS Files on PR Request
+on:
+  pull_request:
+jobs:
+  vue-lint:
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout the current repo
+      - name: Checkout current repository
+        uses: actions/checkout@v3
+      # Setup NodeJS version 14  
+      - name: Setup NodeJS V14.x.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+      # CD into the current client directory and lint and build the client
+      - name: Lint and Build the client  
+        run: |
+          cd ./ErsatzTV/client-app/
+          npm ci --no-optional
+          npm run lint
+          npm run build --if-present

.gitignore

@@ -43,3 +43,4 @@ scripts/generate-api-sdk/swagger.json
 
 docker-compose.override.yml
 
+ErsatzTV/wwwroot/v2/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ErsatzTV-macOS"]
+	path = ErsatzTV-macOS
+	url = git@github.com:jasongdove/ErsatzTV-macOS.git

CHANGELOG.md

@@ -1,10 +1,901 @@
-# Changelog
+ 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.7.4-beta] - 2023-02-12
+### Added
+- Add button to copy/clone schedule from schedules table
+- Synchronize episode tags and genres from Jellyfin, Emby and Local show libraries
+- Add `Deep Scan` button to Jellyfin and Emby libraries
+  - This is now required to update some metadata for existing libraries, when targeted updates are not possible
+  - For example, if you already have tags and genres on your episodes in Jellyfin or Emby, you will need to deep scan each library to update that metadata on existing items in ErsatzTV
+
+### Fixed
+- Fix many QSV pipeline bugs
+- Fix MPEG2 video format with QSV and VAAPI acceleration
+- Fix playback of content with undefined colorspace
+- Fix NVIDIA color normalization with VP9 sources
+- Fix fallback filler looping
+- Fix bug where some libraries would never scan
+- Fix filler ordering so post-roll is properly scheduled after padded mid-roll
+- Fix pre/post-roll filler padding when used with mid-roll
+  - This caused overlapping schedule items, fallback filler that was too long, etc.
+
+### Changed
+- Merge generated `Other Video` folder tags with tags from sidecar NFO
+- Prioritize audio streams that are flagged as "default" when multiple candidate streams are available
+  - For example, a video with a stereo commentary track and a stereo "default" track will now prefer the "default" track 
+
+## [0.7.3-beta] - 2023-01-25
+### Added
+- Attempt to release memory periodically
+- Add OpenID Connect (OIDC) support (e.g. Keycloak, Authelia, Auth0)
+  - This only protects the management UI; all streaming endpoints will continue to allow anonymous access 
+  - This can be configured with the following env vars (note the double underscore separator `__`)
+    - `OIDC__AUTHORITY`
+    - `OIDC__CLIENTID`
+    - `OIDC__CLIENTSECRET`
+    - `OIDC__LOGOUTURI` (optional, needed for Auth0, use `https://{auth0-domain}/v2/logout?client_id={auth0-client-id}` with proper values for domain and client-id)
+- Add *experimental* alternate schedule system
+  - This allows a single playout to dynamically select a schedule based on date criteria, for example:
+    - Weekday vs weekend schedules
+    - Summer vs fall schedules
+    - Shark week schedules
+  - Alternate schedules can be managed by clicking the calendar icon in the playout list
+  - Playouts contain a prioritized (top to bottom) list of alternate schedules
+  - Whenever a playout is built for a given day, ErsatzTV will check for a matching schedule from top to bottom
+  - A given day must match all alternate schedule parameters; wildcards (`*any*`) will always match
+    - Day of week
+    - Day of month
+    - Month
+  - The lowest priority (bottom) item will always match all parameters, and can be considered a "default" or "fallback" schedule 
+
+### Fixed
+- Fix schedule editor crashing due to bad music video artist data
+- Fix bug where playouts would not maintain smart collection progress on schedules that use multiple smart collections
+- Fix library scanning on osx-arm64
+- Fix ability to remove some media server libraries from ErsatzTV
+
+### Changed
+- Always use software pipeline for error display
+  - This ensures errors will display even when hardware acceleration is misconfigured
+- Call scanner process only when scanning is required based on library refresh interval
+- Use lower process priority for scanner process with unforced (automatic) library scans
+- Disable V2 UI and APIs by default
+  - V2 UI can be re-enabled by setting the env var `ETV_UI_V2` to any value
+
+## [0.7.2-beta] - 2023-01-05
+### Fixed
+- Fix VAAPI encoding in docker by switching to non-free driver
+
+### Changed
+- Rewrite log page to read directly from log files instead of sqlite
+
+## [0.7.1-beta] - 2023-01-03
+### Added
+- Add new music video credit templates
+
+### Fixed
+- Fix many transcoding failures caused by the colorspace filter
+- Fix song playback with VAAPI and NVENC
+- Fix edge case where some local movies would not automatically be restored from trash
+- Fix synchronizing Jellyfin and Emby collection items
+- Fix saving some external subtitle records to database 
+
+### Changed
+- Upgrade to dotnet 7
+- Upgrade all docker images to ubuntu jammy and ffmpeg 5.1.2
+- Limit library scan interval between 0 and 1,000,000
+  - 0 means do not automatically scan libraries
+  - 1 to 999,999 means scan if it has been that many hours since the last scan
+- Use new `ErsatzTV.Scanner` process for scanning all libraries
+  - This should reduce the ongoing memory footprint
+
+## [0.7.0-beta] - 2022-12-11
+### Fixed
+- Fix removing Jellyfin and Emby libraries that have been deleted from the source media server
+- Fix `Work-Ahead HLS Segmenter Limit` setting to properly limit number of channels that can work-ahead at once
+- Include base path value in generated channel playlist (M3U) and channel guide (XMLTV) links
+- Fix parsing song metadata from OGG audio files
+- Properly unlock/re-enable trakt list operations after an operation is canceled
+
+### Added
+- Add (required) bit depth normalization option to ffmpeg profile
+  - This can help if your card only supports e.g. h264 encoding, normalizing to 8 bits will allow the hardware encoder to be used
+- Extract font attachments after extracting text subtitles
+  - This should improve SubStation Alpha subtitle rendering
+- Detect VAAPI capabilities and fallback to software decoding/encoding as needed
+- Add audio stream selector scripts for episodes and movies
+  - This will let you customize which audio stream is selected for playback
+  - Episodes are passed the following data:
+    - `channelNumber`
+    - `channelName`
+    - `showTitle`
+    - `showGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `seasonNumber`
+    - `episodeNumber`
+    - `episodeGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+      - `index`: the stream's index number, this is what the function needs to return
+      - `channels`: the number of audio channels
+      - `codec`: the audio codec
+      - `isDefault`: bool indicating whether the stream is flagged as default
+      - `isForced`: bool indicating whether the stream is flagged as forced
+      - `language`: the stream's language
+      - `title`: the stream's title
+  - Movies are passed the following data:
+      - `channelNumber`
+      - `channelName`
+      - `title`
+      - `guids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+        - `index`: the stream's index number, this is what the function needs to return
+        - `channels`: the number of audio channels
+        - `codec`: the audio codec
+        - `isDefault`: bool indicating whether the stream is flagged as default
+        - `isForced`: bool indicating whether the stream is flagged as forced
+        - `language`: the stream's language
+        - `title`: the stream's title
+- Add new fields to search index
+  - `video_codec`: the video codec
+  - `video_bit_depth`: the number of bits in the video stream's pixel format, e.g. 8 or 10
+  - `video_dynamic_range`: the video's dynamic range, either `sdr` or `hdr`
+
+### Changed
+- Change `Multi-Episode Shuffle` scripting system to use Javascript instead of Lua
+
+## [0.6.9-beta] - 2022-10-21
+### Fixed
+- Fix bug where tail or fallback filler would sometimes schedule much longer than expected
+  - This only happened with fixed start schedule items following a schedule item with tail or fallback filler
+- Fix NFO reader bug that caused inaccurate warning messages about invalid XML and incomplete metadata
+- Fix reverse proxy SSL termination support by supporting `X-Forwarded-Proto` header
+- Fix automatic playout reset scheduling
+  - Playouts would reset every 30 minutes between midnight and the configured time, instead of only at the configured time
+- XMLTV: properly group schedule items with `Custom Title` followed by item(s) with `Guide Mode` set to `Filler`
+
+### Added
+- Add music video credits template system
+  - Templates are selected in each channel's settings 
+  - Templates should be copied from `_default.ass.sbntxt` which is located in the config subfolder `templates/music-video-credits`
+    - Copy the file, give it any name ending with `.ass.sbntext`, and only make edits to the copied file
+  - The default template will be extracted and overwritten every time ErsatzTV is started
+  - The template is an [Advanced SubStation Alpha](http://www.tcax.org/docs/ass-specs.htm) file using [scribian](https://github.com/scriban/scriban/tree/master/doc) template syntax
+  - The following fields are available for use in the template:
+    - `resolution`: the ffmpeg profile's resolution, which is used for margin calculations
+    - `title`: the title of the music video
+    - `track`: the music video's track number
+    - `album`: the music video's album
+    - `plot`: the music video's plot
+    - `release_date`: the music video's release date
+    - `artist`: the music videos artist (the parent folder)
+    - `all_artists`: a list of additional artists from the music video's sidecar NFO metadata file
+    - `duration`: the timespan duration of the music video, which can be used to calculate timing of additional subtitles
+    - `stream_seek`: the timespan that ffmpeg will seek into the media item before beginning playback
+- Add `Multi-Episode Shuffle` playout order for `Television Show` schedule items
+  - The purpose of this playout order is to improve randomization for shows that normally have intro, multiple episodes, and outro
+  - This playout order requires splitting the parts into individual files (e.g. splitting `s01e01-03.mkv` into `s01e01.mkv`, `s01e02.mkv` and `s01e03.mkv`)
+  - This playout order requires a lua script in the config subfolder `scripts/multi-episode-shuffle`
+  - The lua script should be named for the television show's guid, e.g. `tvdb_12345.lua` or `imdb_tt123456789.lua`
+  - The script defines the number of parts that each un-split file typically contains
+  - The script also defines a function to map each episode to a part number (or no part number i.e. `nil` if an episode has not been split)
+  - All groups of part numbers (i.e. all part 1s, all part 2s) will be shuffled
+  - The playout order will then schedule a random part 1 followed by a random part 2, etc
+    - Un-split (`nil`) episodes will be randomly placed between re-combined parts (e.g. part1, part2, part3, un-split, part1, part2, part3)
+- Add `ETV_BASE_URL` environment variable to support reverse proxies that use paths (e.g. `/ersatztv`)
+
+### Changed
+- No longer place watermarks within content by default (e.g. within 4:3 content padded to a 16:9 resolution)
+  - This can be re-enabled if desired using the `Place Within Source Content` checkbox in watermark settings
+
+## [0.6.8-beta] - 2022-10-05
+### Fixed
+- Fix typo introduced in `0.6.7-beta` that stopped QSV HEVC encoder from working
+- Fix scaling logic for `Nvidia` acceleration and software mode
+- Attempt to position watermarks within content (not over added black padding)
+- Fix search results for `Other Videos` when NFO metadata is used
+- Properly synchronize tags from Emby movies and shows
+- Properly sync updated file paths from Plex
+- Fix numeric range search queries (e.g. `minutes:[5 TO 10]`, `minutes:[* TO 3]`)
+
+### Added
+- Add `QSV Device` option to ffmpeg profile on linux
+- Add guids to search index (e.g. `imdb:tt000000`, `tvdb:12345`)
+
+## [0.6.7-beta] - 2022-09-05
+### Fixed
+- When all audio streams are selected with `HLS Direct`, explicitly copy them without transcoding
+  - This only happens when the channel does not have a `Preferred Audio Language`
+- Fix scanner crash caused by invalid mtime
+- `VAAPI`: Downgrade libva from 2.15 to 2.14
+- Fix bug with XMLTV that caused some filler to display with primary content details
+- Multiple fixes for content scaling with `Nvidia`, `Qsv` and `Vaapi` accelerations
+- Properly scale image-based subtitles
+- Fix bug where a schedule containing a single item (fixed start and flood) would never finish building a playout
+  - Logic was also added to detect infinite playout build loops in the future and stop them
+- Fix bug where `Other Videos` wouldn't be included in scheduling mode `Shuffle In Order`
+
+### Added
+- Add `Preferred Audio Title` feature
+    - Preference can be configured in channel settings and overridden on schedule items
+    - When a title is specified, audio streams that contain that title (case-insensitive search) will be prioritized
+    - This can be helpful for creating channels that use commentary tracks
+    - External tooling exists to easily update title/name metadata if your audio streams don't already have this metadata
+- Add `Amf` hardware acceleration option for AMD GPUs on Windows
+- Add `QSV Extra Hardware Frames` parameter for tuning QSV acceleration
+  - Performance may improve on some systems after doubling or halving the default value of `64`
+
+## [0.6.6-beta] - 2022-08-17
+### Fixed
+- Use MIME Type `application/x-mpegurl` for all playlists instead of `application/vnd.apple.mpegurl`
+- Replace `setsar` filter with `setdar` filter
+  - `setsar` caused issues scaling between two different aspect ratios
+    - For example, some 4:3 content would appear stretched when scaled to a 16:9 resolution
+  - `setdar` is now only used when aspect ratios match 
+- Prioritize aspect ratio from container when video stream contains conflicting aspect ratio
+  - This is usually caused by bad authoring, but the change should improve scaling behavior for edge cases
+
+### Added
+- Support DSD audio file formats (DFF and DSF) in local song libraries
+- Support OGG audio file formats (OGG, OPUS, OGA, OGX, SPX) in local song libraries
+
+### Changed
+- Always return playlist after a maximum of 8 seconds while starting up an HLS Segmenter session
+- Use multi-variant playlists instead of redirects for HLS Segmenter sessions
+- Upgrade ffmpeg from 5.0 to 5.1 in most docker images (not ARM variants)
+    - Upgrading from 5.0 to 5.1 is also recommended for other installations (Windows, Linux)
+
+## [0.6.5-beta] - 2022-08-02
+### Fixed
+- Fix database initializer; fresh installs with v0.6.4-beta are missing some config data and should upgrade
+
+## [0.6.4-beta] - 2022-07-28
+### Fixed
+- Fix subtitle stream selection when subtitle language is different than audio language
+- Fix bug with unsupported AAC channel layouts
+- Fix NVIDIA second-gen maxwell capabilities detection
+- Return distinct search results for episodes and other videos that have the same title
+  - For example, two other videos both named `Trailer` would previously have displayed as one item in search results
+- Fix schedules that would begin to repeat the same content in the same order after a couple of days
+
+### Added
+- Add `640x480` resolution
+
+## [0.6.3-beta] - 2022-07-04
+### Fixed
+- Maintain stream continuity when playout is rebuilt for a channel that is actively being streamed
+- Properly apply changes to episode title, sort title, outline and plot from Plex
+- Fix search index for other videos and songs
+  - In previous versions, some libraries would incorrectly display only one item
+- Properly display old versions of renamed items in trash
+
+### Added
+- Add `Minimum Log Level` option to `Settings` page
+  - Other methods of configuring the log level will no longer work
+
+## [0.6.2-beta] - 2022-06-18
+### Fixed
+- Fix content repeating for up to a minute near the top of every hour
+- Check whether hardware-accelerated hevc codecs are supported by the NVIDIA card
+  - Software codecs will be used if they are unsupported by the NVIDIA card
+- Fix sorting of channel contents in EPG
+- Fix Jellyfin admin user id sync
+  - Ignore disabled admins and admins who do not have access to all libraries
+
+### Added
+- Add 32-bit `arm` docker tags (`develop-arm` and `latest-arm`)
+
+### Changed
+- Regularly delete old segments from transcode folder while content is actively transcoding
+  - This should help reduce required disk space
+  - To further minimize required disk space, set `Work-Ahead HLS Segmenter Limit` to `0` in `Settings`
+
+## [0.6.1-beta] - 2022-06-03
+### Fixed
+- Fix Jellyfin show library paging
+- Properly locate and identify multiple Plex servers
+- Properly restore `Unavailable`/`File Not Found` items when they are located on disk
+
+### Added
+- Add basic music video credits subtitle generation
+  - This can be enabled in channel settings
+
+## [0.6.0-beta] - 2022-06-01
+### Fixed
+- Additional fix for duplicate `Other Videos` entries; trash may need to be emptied one last time after upgrading
+- Fix watermark opacity in cultures where `,` is a decimal separator
+- Rework playlist filtering to avoid empty playlist responses
+- Fix some QSV/VAAPI memory errors by always requesting 64 extra hardware frames
+
+### Added
+- Enable QSV hardware acceleration for vaapi docker images
+
+### Changed
+- Use paging to synchronize all media from Plex, Jellyfin and Emby
+  - This will reduce memory use and improve reliability of synchronizing large libraries
+- Disable low power mode for `h264_qsv` and `hevc_qsv` encoders
+
+## [0.5.8-beta] - 2022-05-20
+### Fixed
+- Fix error display with `HLS Segmenter` and `MPEG-TS` streaming modes
+- Remove erroneous log messages about normalizing framerate on channels where framerate normalization is disabled
+- Fix unscheduled filler gaps that sometimes happen as playouts are automatically extended each hour
+
+### Added
+- Clean transcode cache folder on startup and after `HLS Segmenter` session terminates for any reason
+
+### Changed
+- Remove thread limitation for scenarios where it is not required
+  - This should give a performance boost to installations that don't use hardware acceleration
+- Use hardware acceleration to display error messages where configured
+
+## [0.5.7-beta] - 2022-05-14
+### Fixed
+- Reduce memory use due to library scan operations
+- Fix some instances of filler getting "stuck" when a filler item is encountered that's too long for the gap
+- Properly ignore Plex `Other Videos` libraries (`movie` libraries where agent is `com.plexapp.agents.none`)
+- Fix `Custom Title` for schedule items with `One`, `Multiple` and `Flood` playout modes 
+- Fix scheduling bug where flood items would sometimes fail to continue after midnight
+
+### Added
+- Add `metadata_kind` field to search index to allow searching for items with a particular metdata source
+  - Valid metadata kinds are `fallback`, `sidecar` (NFO), `external` (from a media server) and `embedded` (songs)
+- Add autocomplete functionality to search bar to quickly navigate to channels, ffmpeg profiles, collections and schedules by name
+- Add global setting to skip missing (file-not-found or unavailable) items when building playouts
+- Add filler preset option to allow watermarks to overlay on top of filler (disabled by default)
+  - This option is applied when new items are added to a playout; rebuilding is needed if you want the change to take effect immediately
+- Read `track` field from music video NFO metadata and use it for chronological sorting (after release date)
+- Add `Random Start Point` option to schedules
+  - When this option is enabled, all `Chronological` or `Shuffle In Order` content groups will have their start points randomized
+  - When this option is disabled, all `Chronological` or `Shuffle In Order` content groups will start with the chronologically earliest item
+
+### Changed
+- Replace invalid (control) characters in NFO metadata with replacement character `<60>` before parsing
+- Store partial (incomplete) NFO metadata results when invalid XML is encountered
+  - Previously, no metadata would be stored if the XML within the NFO failed to validate
+
+## [0.5.6-beta] - 2022-05-06
+### Fixed
+- Fix processing local movie NFO metadata without a `year` value
+- Fix processing local movie fallback metadata
+- Fix search edge case where very recently added items (hours) would not be returned by relative date queries
+- Fix search index validation on startup; improper validation was causing a rebuild with every startup
+- Block library scanning until search index has been recreated/upgraded
+- Fix occasional erroneous log messages when HLS channel playback times out because all clients have left
+- Fix fallback filler playback
+- Fix stream continuity when error messages are displayed
+- Fix duplicate scanning within `Other Video` libraries (i.e. folders would be scanned multiple times) 
+
+### Added
+- Add `show_genre` and `show_tag` to search index for seasons and episodes
+- Use `aired` value to source release date from music video nfo metadata
+- Add NFO metadata support to `Other Video` libraries
+  - `Other Video` NFO metadata must be in the movie NFO metadata format
+
+## [0.5.5-beta] - 2022-05-03
+### Fixed
+- Fix adding episodes with no title to the search index
+  - This behavior was preventing some items from being removed from the trash
+- Support combination NFO metadata for movies, shows, artists and music videos
+  - Note that ErsatzTV does not scrape any metadata; any URLs after the XML will be ignored
+- Fix bug causing some Jellyfin and Emby content to incorrectly show as unavailable
+- Fix extracting embedded `mov_text` subtitles
+- Properly extract embedded subtitles on playouts where subtitles are only enabled on schedule items (and not on the channel itself)
+
+### Added
+- Add experimental `arm64` docker tags (`develop-arm64` and `latest-arm64`)
+- Use `Sort Title` from Movie NFO metadata if available
+- Support multiple `Artist` entries in music video NFO metadata
+
+## [0.5.4-beta] - 2022-04-29
+### Fixed
+- Cleanly stop all library scans when service termination is requested
+- Fix health check crash when trash contains a show or a season
+- Fix ability of health check crash to crash home page
+- Remove and ignore Season 0/Specials from Plex shows that have no specials
+- Automatically delete and rebuild the search index on startup if it has become corrupt
+- Automatically scan Jellyfin and Emby libraries on startup and periodically
+- Properly remove un-synchronized Plex, Jellyfin and Emby items from the database and search index
+- Fix synchronizing movies within a collection from Jellyfin
+
+### Changed
+- Update Plex, Jellyfin and Emby movie and show library scanners to share a significant amount of code
+  - This should help maintain feature parity going forward
+- Optimize search-index rebuilding to complete 100x faster
+- **No longer use network paths to source content from Jellyfin and Emby**
+  - **If you previously used path replacements to convert network paths to local paths, you should remove them**
+
+### Added
+- Add `unavailable` state for Jellyfin and Emby movie and show libraries
+- Add `height` and `width` to search index for all videos
+- Add `season_number` and `episode_number` to search index for all episodes
+- Add `season_number` to search index for seasons
+- Add `show_title` to search index for seasons and episodes
+
+## [0.5.3-beta] - 2022-04-24
+### Fixed
+- Cleanly stop Plex library scan when service termination is requested
+- Fix bug introduced with 0.5.2-beta that prevented some Plex content from being played
+- Fix spammy subtitle error message
+- Fix generating blur hashes for song backgrounds in Docker
+
+### Changed
+- No longer remove Plex movies and episodes from ErsatzTV when they do not exist on disk
+  - Instead, a new `unavailable` media state will be used to indicate this condition
+  - After updating mounts, path replacements, etc - a library scan can be used to resolve this state
+
+## [0.5.2-beta] - 2022-04-22
+### Fixed
+- Fix unlocking libraries when scanning fails for any reason
+- Fix software overlay of actual size watermark
+
+### Added
+- Add support for burning in embedded and external text subtitles
+  - **This requires a one-time full library scan, which may take a long time with large libraries.**
+- Sync Plex, Jellyfin and Emby collections as tags on movies, shows, seasons and episodes
+  - This allows smart collections that use queries like `tag:"Collection Name"`
+  - Note that Emby has an outstanding collections bug that prevents updates when removing items from a collection
+- Sync Plex labels as tags on movies and shows
+  - This allows smart collections that use queries like `tag:"Plex Label Name"`
+- Add `Deep Scan` button for Plex libraries
+  - This scanning mode is *slow* but is required to detect some changes like labels
+
+### Changed
+- Improve the speed and change detection of the Plex library scanners
+
+## [0.5.1-beta] - 2022-04-17
+### Fixed
+- Fix subtitles edge case with NVENC
+- Only select picture subtitles (text subtitles are not yet supported)
+  - Supported picture subtitles are `hdmv_pgs_subtitle` and `dvd_subtitle`
+- Fix subtitles using software encoders, videotoolbox, VAAPI
+- Fix setting VAAPI driver name
+- Fix ffmpeg troubleshooting reports
+- Fix bug where filler would behave as if it were configured to pad even though a different mode was selected
+- Fix bug where mid-roll count filler would skip scheduling the final chapter in an episode 
+
+### Added
+- Add `Empty Trash` button to `Trash` page
+
+## [0.5.0-beta] - 2022-04-13
+### Fixed
+- Fix `HLS Segmenter` bug where it would drift off of the schedule if a playout was changed while the segmenter was running
+- Ensure clients that use HDHomeRun emulation (like Plex) always get an `MPEG-TS` stream, regardless of the configured streaming mode
+- Fix scheduling bug that caused some days to be skipped when fixed start times were used with fallback filler
+
+### Added
+- Add `Preferred Subtitle Language` and `Subtitle Mode` to channel settings
+  - `Preferred Subtitle Language` will filter all subtitle streams based on language
+  - `Subtitle Mode` will further filter subtitle streams based on attributes (forced, default)
+  - If picture-based subtitles are found after filtering, they will be burned into the video stream
+- Detect non-zero ffmpeg exit code from `HLS Segmenter` and `MPEG-TS`, log error output and display error output on stream
+- Add `Watermark` setting to schedule items; this allows override the channel watermark. Watermark priority is:
+  - Schedule Item
+  - Channel
+  - Global
+
+### Changed
+- Remove legacy transcoder logic option; all channels will use the new transcoder logic
+- Renamed channel setting `Preferred Language` to `Preferred Audio Language`
+- Reworked playout build logic to maintain collection progress in some scenarios. There are now three build modes:
+  - `Continue` - add new items to the end of an existing playout
+    - This mode is used when playouts are automatically extended in the background
+  - `Refresh` - this mode will try to maintain collection progress while rebuilding the entire playout
+    - This mode is used when a schedule is updated, or when collection modifications trigger a playout rebuild
+  - `Reset` - this mode will rebuild the entire playout and will NOT maintain progress
+    - This mode is only used when the `Reset Playout` button is clicked on the Playouts page
+  - **This requires rebuilding all playouts, which will happen on startup after upgrading**
+- Use ffmpeg to resize images; this should help reduce ErsatzTV's memory use
+- Use ffprobe to check for animated logos and watermarks; this should help reduce ErsatzTV's memory use
+- Allow two decimals in channel numbers (e.g. `5.73`)
+
+## [0.4.5-alpha] - 2022-03-29
+### Fixed
+- Fix streaming mode inconsistencies when `mode` parameter is unspecified
+- Fix startup on Windows 7
+
+### Added
+- Add option to automatically deinterlace video when transcoding
+  - Previously, this was always enabled; the purpose of the option is to allow disabling any deinterlace filters
+  - Note that there is no performance gain to disabling the option with progressive content; filters are only ever applied to interlaced content
+
+### Changed
+- Change FFmpeg Profile video codec and audio codec text fields to select fields
+  - The appropriate video encoder will be determined based on the video format and hardware acceleration selections
+- Remove FFmpeg Profile `Transcode`, `Normalize Video` and `Normalize Audio` settings
+  - All content will be transcoded and have audio and video normalized
+  - The only exception to this rule is `HLS Direct` streaming mode, which directly copies video and audio streams
+- Always try to connect to Plex at `http://localhost:32400` even if that address isn't advertised by the Plex API
+  - If Plex isn't on the localhost, all other addresses will be checked as with previous releases
+
+## [0.4.4-alpha] - 2022-03-10
+### Fixed
+- Fix `HLS Direct` streaming mode
+- Fix bug with `HLS Segmenter` (and `MPEG-TS`) on Windows that caused errors at program boundaries
+
+### Added
+- Perform additional duration analysis on files with missing duration metadata
+- Add `nouveau` VAAPI driver option
+
+## [0.4.3-alpha] - 2022-03-05
+### Fixed
+- Fix song sorting with `Chronological` and `Shuffle In Order` playback orders
+- Fix watermark on scaled and/or padded video with NVIDIA acceleration
+- Fix playback of interlaced mpeg2video content with NVIDIA acceleration
+- Fix playback of all interlaced content with QSV acceleration
+- Fix adding songs to collections from search results page
+- Fix bug scheduling mid-roll filler with content that contains one chapter
+  - No mid-roll filler will be inserted for content with zero or one chapters
+- Fix thread sync bug with `HLS Segmenter` (and `MPEG-TS`) streaming modes
+- Fix path replacement bug when media server path is left blank
+
+### Added
+- Add automated error reporting via Bugsnag
+  - This can be disabled by editing the `appsettings.json` file or by setting the `Bugsnag:Enable` environment variable to `false`
+- Add `album_artist` to song metadata and to search index
+- Display `album_artist` on some song videos when it's different than the `artist`
+
+### Changed
+- Framerate normalization will never normalize framerate below 24fps
+  - Instead, content with a lower framerate will be normalized up to 24fps
+- `Shuffle In Order` will group songs by album artist instead of by track artist
+
+## [0.4.2-alpha] - 2022-02-26
+### Fixed
+- Add improved but experimental transcoder logic, which can be toggled on and off in `Settings`
+- Fix `HLS Segmenter` bug when source video packet contains no duration (`N/A`)
+- Fix green line at the bottom of some content scaled using QSV acceleration
+
+### Added
+- Add configurable channel group (M3U) and categories (XMLTV)
+- Add `Shuffle Schedule Items` option to schedule configuration
+  - When this is enabled, schedule items will be shuffled rather than looped in order
+  - **To support this, all playouts will be rebuilt (one time) after upgrading to this version**
+
+### Changed
+- Disable framerate normalization by default and on all ffmpeg profiles
+  - If framerate normalization is desired (not typically needed), it can be re-enabled manually
+- Show watermarks over songs
+- Hide unused local libraries
+
+## [0.4.1-alpha] - 2022-02-10
+### Fixed
+- Normalize smart quotes in search queries as they are unsupported by the search library
+- Fix incorrect watermark time calculations caused by working ahead in `HLS Segmenter`
+- Fix ui crash adding empty path to local library
+- Fix ui crash loading collection editor
+- Properly flag items as `File Not Found` when local library path (folder) is missing from disk
+- Fix playback bug with unknown pixel format
+- Fix playback of interlaced mpeg2video on NVIDIA, VAAPI
+
+### Added
+- Include `Series` category tag for all episodes in XMLTV
+- Include movie, episode (show), music video (artist) genres as `category` tags in XMLTV
+- Add framerate normalization to `HLS Segmenter` and `MPEG-TS` streaming modes
+- Add `HLS Segmenter Initial Segment Count` setting to allow segmenter to work ahead before allowing client playback
+
+### Changed
+- Intermittent watermarks will now fade in and out
+- Show collection name in some playout build error messages
+- Use hardware-accelerated filter for watermarks on NVIDIA
+- Use hardware-accelerated deinterlace for some content on NVIDIA
+
+## [0.4.0-alpha] - 2022-01-29
+### Fixed
+- Fix m3u `mode` query param to properly override streaming mode for all channels
+  - `segmenter` for `HLS Segmenter`
+  - `hls-direct` for `HLS Direct`
+  - `ts` for `MPEG-TS`
+  - `ts-legacy` for `MPEG-TS (Legacy)`
+  - omitting the `mode` parameter returns each channel as configured
+- Link `File Not Found` health check to `Trash` page to allow deletion
+- Fix `HLS Segmenter` streaming mode with multiple ffmpeg-based clients
+  - Jellyfin (web) and TiviMate (Android) were specifically tested
+
+### Added
+- Hide console window on macOS and Windows; tray menu can be used to access UI, logs and to stop the app
+- Also write logs to text files in the `logs` config subfolder
+- Add `added_date` to search index
+    - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+- Add `added_inthelast`, `added_notinthelast` search field for relative added date queries
+    - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
+
+## [0.3.8-alpha] - 2022-01-23
+### Fixed
+- Fix issue preventing some versions of ffmpeg (usually 4.4.x) from streaming MPEG-TS (Legacy) channels at all
+  - The issue appears to be caused by using a thread count other than `1`
+  - Thread count is now forced to `1` for all streaming modes other than HLS Segmenter
+- Fix bug with HLS Segmenter in cultures where `.` is a group/thousands separator
+- Fix search results page crashing with some media kinds
+- Always use MPEG-TS or MPEG-TS (Legacy) streaming mode with HDHR (Plex)
+  - Other configured modes will fall back to MPEG-TS when accessed by Plex
+
+### Changed
+- Upgrade ffmpeg from 4.4 to 5.0 in all docker images
+    - Upgrading from 4.4 to 5.0 is recommended for all installations
+
+## [0.3.7-alpha] - 2022-01-17
+### Fixed
+- Fix local folder scanners to properly detect removed/re-added folders with unchanged contents
+- Fix double-click startup on mac
+- Fix trakt list sync when show does not contain a year
+- Properly unlock libraries when a scan is unable to be performed because ffmpeg or ffprobe have not been found
+
+### Added
+- Add trash system for local libraries to maintain collection and schedule integrity through media share outages
+  - When items are missing from disk, they will be flagged and present in the `Media` > `Trash` page
+  - The trash page can be used to permanently remove missing items from the database
+  - When items reappear at the expected location on disk, they will be unflagged and removed from the trash
+- Add basic Mac hardware acceleration using VideoToolbox
+
+### Changed
+- Local libraries only: when items are missing from disk, they will be added to the trash and no longer removed from collections, etc.
+- Show song thumbnail in song list
+
+## [0.3.6-alpha] - 2022-01-10
+### Fixed
+- Properly index `minutes` field when adding new items during scan (vs when rebuilding index)
+- Fix some nvenc edge cases where only padding is needed for normalization
+- Properly overwrite environment variables for ffmpeg processes (`LIBVA_DRIVER_NAME`, `FFREPORT`)
+
+### Added
+- Add music video `artist` to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove `HLS Hybrid` streaming mode; all channels have been reconfigured to use the superior `HLS Segmenter` streaming mode
+- Update `MPEG-TS` streaming mode to internally use the HLS segmenter
+  - This improves compatibility with many clients and also improves performance at program boundaries
+- Renamed existing `MPEG-TS` mode as `MPEG-TS (Legacy)`
+  - This mode will be removed in a future release
+
+## [0.3.5-alpha] - 2022-01-05
+### Fixed
+- Fix bundled ffmpeg version in base docker image (NOT nvidia or vaapi) which prevented playback since v0.3.0-alpha
+- Use software decoding for mpeg4 content when VAAPI acceleration is enabled
+- Fix hardware acceleration health check to recognize QSV on non-Windows platforms
+
+### Changed
+- Treat `setsar` as a hardware filter, avoiding unneeded `hwdownload` and `hwupload` steps when padding isn't required
+
+## [0.3.4-alpha] - 2021-12-21
+### Fixed
+- Fix other video and song scanners to include videos contained directly in top-level folders that are added to a library
+- Allow saving ffmpeg troubleshooting reports on Windows
+
+## [0.3.3-alpha] - 2021-12-12
+### Fixed
+- Fix bug with saving multiple blurhash versions for cover art; all cover art will be automatically rescanned
+- Fix song detail margin when no cover art exists and no watermark exists
+- Fix synchronizing virtual shows and seasons from Jellyfin
+- Properly sort channels in M3U
+
+### Changed
+- Use blurhash of ErsatzTV colors instead of solid colors for default song backgrounds
+- Use select control instead of autocomplete control in many places
+    - The autocomplete control is not intuitive to use and has focus bugs
+
+## [0.3.2-alpha] - 2021-12-03
+### Fixed
+- Fix artwork upload on Windows
+- Fix unicode song metadata on Windows
+- Fix unicode console output on Windows
+- Fix TV Show NFO metadata processing when `year` is missing
+- Fix song detail outline to help legibility on white backgrounds
+- Optimize song artwork scanning to prevent re-processing album artwork for each song
+
+### Changed
+- Use custom log database backend which should be more portable (i.e. work in osx-arm64)
+- Use cover art blurhashes for song backgrounds instead of solid colors or box blur
+
+## [0.3.1-alpha] - 2021-11-30
+### Fixed
+- Fix song page links in UI
+- Show song artist in playout detail
+- Include song artist and cover art in channel guide (xmltv)
+- Use subtitles to display errors, which fixes many edge cases of unescaped characters
+- Properly split song genre tags
+- Properly display all songs that have an identical album and title
+- Fix channel logo and watermark uploads
+- Fix regression introduced with `v0.2.4-alpha` that caused some filler edge cases to crash the playout builder
+
+### Added
+- Add song genres to search index
+- Use embedded song cover art when sidecar cover art is unavailable
+
+### Changed
+- Randomly place song cover art on left or right side of screen
+- Randomly use a solid color from the cover art instead of blurred cover art for song background
+- Randomly select song detail layout (large title/small artist or small artist/title/album)
+
+## [0.3.0-alpha] - 2021-11-25
+### Fixed
+- Properly fix database incompatibility introduced with `v0.2.4-alpha` and partially fixed with `v0.2.5-alpha`
+  - The proper fix requires rebuilding all playouts, which will happen on startup after upgrading
+- Fix local library locking/progress display when adding paths
+- Fix grouping duration items in EPG when custom title is configured
+
+### Added
+- Add *experimental* `Songs` local libraries
+    - Like `Other Videos`, `Songs` require no metadata or particular folder layout, and will have tags added for each containing folder
+    - For Example, a song at `rock/band/1990 - Album/01 whatever.flac` will have the tags `rock`, `band` and `1990 - Album`, and the title `01 whatever`
+    - Songs will also have basic metadata read from embedded tags (album, artist, title)
+    - Video will be automatically generated for songs using metadata and cover art or watermarks if available
+- Add support for `.webm` video files
+
+## [0.2.5-alpha] - 2021-11-21
+### Fixed
+- Include other video title in channel guide (xmltv)
+- Fix bug introduced with 0.2.4-alpha that caused some playouts to build from year 0
+- Use less memory matching Trakt list items
+
+### Added
+- Build osx-arm64 packages on release
+
+### Changed
+- No longer warn about local Plex guids; they aren't used for Trakt matching and can be ignored
+
+## [0.2.4-alpha] - 2021-11-13
+### Changed
+- Upgrade to dotnet 6
+- Use `scale_cuda` instead of `scale_npp` for NVIDIA scaling in all cases
+
+## [0.2.3-alpha] - 2021-11-03
+### Fixed
+- Fix bug with audio filter in cultures where `.` is a group/thousands separator
+- Fix bug where flood playout mode would only schedule one item
+  - This would happen if the flood was followed by another flood with a fixed start time
+
+### Added
+- Support empty `.etvignore` file to instruct local movie scanner to ignore the containing folder
+
+## [0.2.2-alpha] - 2021-10-30
+### Fixed
+- Fix EPG entries for Duration schedule items that play multiple items
+- Fix EPG entries for Multiple schedule items that play more than one item
+
+### Added
+- Add fallback filler settings to Channel and global FFmpeg Settings
+  - When streaming is attempted during an unscheduled gap, the resulting video will be determined using the following priority:
+    - Channel fallback filler
+    - Global fallback filler
+    - Generated `Channel Is Offline` error message video 
+
+### Changed
+- Allow per-episode folders for local show libraries
+  - e.g. `Show Name\Season #\Episode #\Show Name - s#e#.mkv`
+
+## [0.2.1-alpha] - 2021-10-24
+### Fixed
+- Fix saving dynamic start time on schedule items
+
+## [0.2.0-alpha] - 2021-10-23
+### Fixed
+- Fix generated streams with mpeg2video
+- Fix incorrect row count in playout detail table
+- Fix deleting movies that have been removed from Jellyfin and Emby
+- Fix bug that caused large unscheduled gaps in playouts
+  - This was caused by schedule items with a fixed start of midnight
+
+### Added
+- Add new filler system
+    - `Pre-Roll Filler` plays before each media item
+    - `Mid-Roll Filler` plays between media item chapters
+    - `Post-Roll Filler` plays after each media item
+    - `Tail Filler` plays after all media items, until the next media item
+    - `Fallback Filler` loops instead of default offline image to fill any remaining gaps
+- Store chapter details with media statistics; this is needed to support mid-roll filler
+    - This requires re-ingesting statistics for all media items the first time this version is launched
+- Add switch to show/hide filler in playout detail table
+- Add `minutes` field to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Change some debug log messages to info so they show by default again
+- Remove tail collection options from `Duration` playout mode
+- Show localized start time in schedule items tables
+
+## [0.1.5-alpha] - 2021-10-18
+### Fixed
+- Fix double scheduling; this could happen if the app was shutdown during a playout build
+- Fix updating Jellyfin and Emby TV seasons
+- Fix updating Jellyfin and Emby artwork
+- Fix Plex, Jellyfin, Emby worker crash attempting to sync library that no longer exists
+- Fix bug with `Duration` mode scheduling when media items are too long to fit in the requested duration
+
+### Added
+- Include music video thumbnails in channel guide (xmltv)
+
+### Changed
+- Automatically find working Plex address on startup
+- Automatically select schedule item in schedules that contain only one item
+- Change default log level from `Debug` to `Information`
+  - The `Debug` log level can be enabled in the `appsettings.json` file for non-docker installs
+  - The `Debug` log level can be enabled by setting the environment variable `Serilog:MinimumLevel=Debug` for docker installs
+
+## [0.1.4-alpha] - 2021-10-14
+### Fixed
+- Fix error message/offline stream continuity with channels that use HLS Segmenter
+- Fix removing items from search index when folders are removed from local libraries
+
+### Added
+- Add `Other Video` local libraries
+  - Other video items require no metadata or particular folder layout, and will have tags added for each containing folder
+  - For Example, a video at `commercials/sd/1990/whatever.mkv` will have the tags `commercials`, `sd` and `1990`, and the title `whatever`
+- Add filler `Tail Mode` option to `Duration` playout mode (in addition to existing `Offline` option)
+  - Filler collection will always be randomized (to fill as much time as possible)
+  - Filler will be hidden from channel guide, but visible in playout details in ErsatzTV
+  - Unfilled time will show offline image
+- Add `Guide Mode` option to all schedule items
+  - `Normal` guide mode will show all scheduled items in the channel guide (xmltv)
+  - `Filler` guide mode will hide all scheduled items from the channel guide, and extend the end time for the previous item in the guide
+
+## [0.1.3-alpha] - 2021-10-13
+### Fixed
+- Fix startup bug for some docker installations
+
+## [0.1.2-alpha] - 2021-10-12
+### Added
+- Include more cuda (nvidia) filters in docker image
+- Enable deinterlacing with nvidia using new `yadif_cuda` filter
+- Add two HLS Segmenter settings: idle timeout and work-ahead limit
+  - `HLS Segmenter Idle Timeout` - the number of seconds to keep transcoding a channel while no requests have been received from any client
+    - This setting must be greater than or equal to 30 (seconds)
+  - `Work-Ahead HLS Segmenter Limit` - the number of segmenters (channels) that will work-ahead simultaneously (if multiple channels are being watched)
+    - "working ahead" means transcoding at full speed, which can take a lot of resources
+    - This setting must be greater than or equal to 0
+- Add more watermark locations ("middle" of each side)
+- Add `VAAPI Device` setting to ffmpeg profile to support installations with multiple video cards
+- Add *experimental* `RadeonSI` option for `VAAPI Driver` and include mesa drivers in vaapi docker image
+
+### Changed
+- Upgrade ffmpeg from 4.3 to 4.4 in all docker images
+  - Upgrading from 4.3 to 4.4 is recommended for all installations
+- Move `VAAPI Driver` from settings page to ffmpeg profile to support installations with multiple video cards
+
+### Fixed
+- Fix some transcoding edge cases with nvidia and pixel format `yuv420p10le`
+
+## [0.1.1-alpha] - 2021-10-10
+### Added
+- Add music video album to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove forced initial delay from `HLS Segmenter` streaming mode
+- Upgrade nvidia docker image from 18.04 to 20.04
+
+## [0.1.0-alpha] - 2021-10-08
+### Added
+- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`) 
+  - This mode is intended to increase client compatibility and reduce issues at program boundaries
+  - If you want the temporary transcode files to be located on a particular drive, the docker path is `/root/.local/share/etv-transcode`
+- Store frame rate with media statistics; this is needed to support HLS Segmenter
+  - This requires re-ingesting statistics for all media items the first time this version is launched
+
+### Changed
+- Use latest iHD driver (21.2.3 vs 20.1.1) in vaapi docker images
+
+### Fixed
+- Add downsampling to support transcoding 10-bit HEVC content with the h264_vaapi encoder
+- Fix updating statistics when media items are replaced
+- Fix XMLTV generation when scheduled episode is missing metadata
+
+## [0.0.62-alpha] - 2021-10-05
+### Added
+- Support IMDB ids from Plex libraries, which may improve Trakt matching for some items
+
+### Fixed
+- Include Specials/Season 0 `episode-num` entry in XMLTV
+- Fix some transcoding edge cases with VAAPI and pixel formats `yuv420p10le`, `yuv444p10le` and `yuv444p`
+- Update Plex movie and episode paths when they are changed within Plex
+- Always use `libx264` software encoder for error messages
+
 ## [0.0.61-alpha] - 2021-09-30
 ### Fixed
 - Revert nvenc/cuda filter change from v60
@@ -634,7 +1525,59 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.61-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.4-beta...HEAD
+[0.7.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.3-beta...v0.7.4-beta
+[0.7.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.2-beta...v0.7.3-beta
+[0.7.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.1-beta...v0.7.2-beta
+[0.7.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.0-beta...v0.7.1-beta
+[0.7.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.9-beta...v0.7.0-beta
+[0.6.9-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.8-beta...v0.6.9-beta
+[0.6.8-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.7-beta...v0.6.8-beta
+[0.6.7-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.6-beta...v0.6.7-beta
+[0.6.6-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.5-beta...v0.6.6-beta
+[0.6.5-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.4-beta...v0.6.5-beta
+[0.6.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.3-beta...v0.6.4-beta
+[0.6.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.2-beta...v0.6.3-beta
+[0.6.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.1-beta...v0.6.2-beta
+[0.6.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.0-beta...v0.6.1-beta
+[0.6.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.8-beta...v0.6.0-beta
+[0.5.8-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.7-beta...v0.5.8-beta
+[0.5.7-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.6-beta...v0.5.7-beta
+[0.5.6-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.5-beta...v0.5.6-beta
+[0.5.5-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.4-beta...v0.5.5-beta
+[0.5.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.3-beta...v0.5.4-beta
+[0.5.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.2-beta...v0.5.3-beta
+[0.5.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.1-beta...v0.5.2-beta
+[0.5.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.0-beta...v0.5.1-beta
+[0.5.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.5-alpha...v0.5.0-beta
+[0.4.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.4-alpha...v0.4.5-alpha
+[0.4.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.3-alpha...v0.4.4-alpha
+[0.4.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.2-alpha...v0.4.3-alpha
+[0.4.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.1-alpha...v0.4.2-alpha
+[0.4.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.0-alpha...v0.4.1-alpha
+[0.4.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.8-alpha...v0.4.0-alpha
+[0.3.8-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.7-alpha...v0.3.8-alpha
+[0.3.7-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.6-alpha...v0.3.7-alpha
+[0.3.6-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.5-alpha...v0.3.6-alpha
+[0.3.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.4-alpha...v0.3.5-alpha
+[0.3.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.3-alpha...v0.3.4-alpha
+[0.3.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.2-alpha...v0.3.3-alpha
+[0.3.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.1-alpha...v0.3.2-alpha
+[0.3.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.0-alpha...v0.3.1-alpha
+[0.3.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.5-alpha...v0.3.0-alpha
+[0.2.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.4-alpha...v0.2.5-alpha
+[0.2.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.3-alpha...v0.2.4-alpha
+[0.2.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.2-alpha...v0.2.3-alpha
+[0.2.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.1-alpha...v0.2.2-alpha
+[0.2.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.0-alpha...v0.2.1-alpha
+[0.2.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.5-alpha...v0.2.0-alpha
+[0.1.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...v0.1.5-alpha
+[0.1.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...v0.1.4-alpha
+[0.1.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.2-alpha...v0.1.3-alpha
+[0.1.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.1-alpha...v0.1.2-alpha
+[0.1.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.0-alpha...v0.1.1-alpha
+[0.1.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.62-alpha...v0.1.0-alpha
+[0.0.62-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.61-alpha...v0.0.62-alpha
 [0.0.61-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.60-alpha...v0.0.61-alpha
 [0.0.60-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.59-alpha...v0.0.60-alpha
 [0.0.59-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.58-alpha...v0.0.59-alpha
@@ -693,4 +1636,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 [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
+[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha

ErsatzTV-Windows/.gitignore

@@ -0,0 +1,2 @@
+target/
+

ErsatzTV-Windows/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "ersatztv_windows"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tray-item = { git = "https://github.com/olback/tray-item-rs" }
+special-folder = { git = "https://github.com/masinc/special-folder-rs" }
+process_path = "0.1.4"
+
+[dependencies.windows]
+version = "0.43.0"
+features = [
+    "Win32_System_Console",
+    "Win32_Foundation"
+]
+
+[build-dependencies]
+windres = "*"

ErsatzTV-Windows/build.rs

@@ -0,0 +1,5 @@
+use windres::Build;
+
+fn main() {
+    Build::new().compile("ersatztv_windows.rc").unwrap();
+}

ErsatzTV-Windows/ersatztv_windows.rc

@@ -0,0 +1,2 @@
+id ICON "ersatztv.ico"
+ersatztv-icon ICON "ersatztv.ico"

ErsatzTV-Windows/src/main.rs

@@ -0,0 +1,112 @@
+#![windows_subsystem = "windows"]
+
+use special_folder::SpecialFolder;
+use std::fs;
+use std::os::windows::process::CommandExt;
+use std::process::Child;
+use std::process::Command;
+use std::process::Stdio;
+use windows::Win32::System::Console;
+use {std::sync::mpsc, tray_item::TrayItem};
+
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+enum Message {
+    Exit,
+}
+
+fn main() {
+    let mut tray = TrayItem::new("ErsatzTV", "ersatztv-icon").unwrap();
+
+    let (tx, rx) = mpsc::channel();
+
+    tray.add_menu_item("Launch Web UI", || {
+        let _ = Command::new("cmd")
+            .creation_flags(CREATE_NO_WINDOW)
+            .arg("/C")
+            .arg("start")
+            .arg("http://localhost:8409")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn();
+    })
+        .unwrap();
+
+    tray.add_menu_item("Show Logs", || {
+        let path = SpecialFolder::LocalApplicationData
+            .get()
+            .unwrap()
+            .join("ersatztv")
+            .join("logs");
+        match path.to_str() {
+            None => {}
+            Some(folder) => {
+                fs::create_dir_all(folder).unwrap();
+                let _ = Command::new("cmd")
+                    .creation_flags(CREATE_NO_WINDOW)
+                    .arg("/C")
+                    .arg("start")
+                    .arg(folder)
+                    .stdin(Stdio::null())
+                    .stdout(Stdio::null())
+                    .stderr(Stdio::null())
+                    .spawn();
+            }
+        }
+    })
+        .unwrap();
+
+    tray.inner_mut().add_separator().unwrap();
+
+    tray.add_menu_item("Exit", move || {
+        tx.send(Message::Exit).unwrap();
+    })
+        .unwrap();
+
+    let path = process_path::get_executable_path();
+    let mut child: Option<Child> = None;
+    match path {
+        None => {}
+        Some(path) => {
+            let etv = path.parent().unwrap().join("ErsatzTV.exe");
+            if etv.exists() {
+                match etv.to_str() {
+                    None => {}
+                    Some(etv) => {
+                        child = Some(
+                            Command::new(etv)
+                                .creation_flags(CREATE_NO_WINDOW)
+                                .stdin(Stdio::null())
+                                .stdout(Stdio::null())
+                                .stderr(Stdio::null())
+                                .spawn()
+                                .unwrap(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    loop {
+        match rx.recv() {
+            Ok(Message::Exit) => {
+                match child {
+                    None => {}
+                    Some(mut child) => {
+                        unsafe {
+                            if Console::AttachConsole(child.id()) == true
+                            {
+                                Console::GenerateConsoleCtrlEvent(Console::CTRL_C_EVENT, 0);
+                            }
+                        }
+                        child.wait().unwrap();
+                    }
+                }
+                break;
+            }
+            _ => {}
+        }
+    }
+}

ErsatzTV.Application/Artists/ArtistViewModel.cs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -1,29 +1,44 @@
-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 ErsatzTV.Application.MediaItems;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaItems.Mapper;
 
-namespace ErsatzTV.Application.Artists.Queries
+namespace ErsatzTV.Application.Artists;
+
+public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
 {
-    public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllArtistsHandler(IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IArtistRepository _artistRepository;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+    public async Task<List<NamedMediaItemViewModel>> Handle(
+        GetAllArtists request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        public Task<List<NamedMediaItemViewModel>> Handle(
-            GetAllArtists request,
-            CancellationToken cancellationToken) =>
-            _artistRepository.GetAllArtists()
-                .Map(
-                    list => list.Filter(
-                        a => !string.IsNullOrWhiteSpace(
-                            a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+        List<Artist> allArtists = await dbContext.Artists
+            .AsNoTracking()
+            .Include(a => a.ArtistMetadata)
+            .ToListAsync(cancellationToken: cancellationToken);
+            
+        return allArtists.Bind(a => ProjectArtist(a)).ToList();
+    }
+
+    private static Option<NamedMediaItemViewModel> ProjectArtist(Artist a)
+    {
+        foreach (ArtistMetadata metadata in a.ArtistMetadata.HeadOrNone())
+        {
+            if (!string.IsNullOrWhiteSpace(metadata.Title))
+            {
+                return ProjectToViewModel(a);
+            }
+        }
+
+        return None;
     }
 }

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,14 +1,22 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Channels
-{
-    public record ChannelViewModel(
-        int Id,
-        string Number,
-        string Name,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId);
-}
+namespace ErsatzTV.Application.Channels;
+
+public record ChannelViewModel(
+    int Id,
+    string Number,
+    string Name,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int PlayoutCount,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate);

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,17 +1,22 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record CreateChannel
-    (
-        string Name,
-        string Number,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, CreateChannelResult>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannel
+(
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,135 +1,177 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
 {
-    public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateChannelResult>> Handle(
+        CreateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await validation.Apply(c => PersistChannel(dbContext, c));
+    }
 
-        public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+    private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
+    {
+        await dbContext.Channels.AddAsync(channel);
+        await dbContext.SaveChangesAsync();
+        return new CreateChannelResult(channel.Id);
+    }
 
-        public async Task<Either<BaseError, CreateChannelResult>> Handle(
-            CreateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistChannel(dbContext, c));
-        }
-
-        private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
-        {
-            await dbContext.Channels.AddAsync(channel);
-            await dbContext.SaveChangesAsync();
-            return new CreateChannelResult(channel.Id);
-        }
-
-        private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
-            (ValidateName(request), await ValidateNumber(dbContext, request),
-                await FFmpegProfileMustExist(dbContext, request),
-                ValidatePreferredLanguage(request),
-                await WatermarkMustExist(dbContext, request))
-            .Apply(
-                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId) =>
-                {
-                    var artwork = new List<Artwork>();
-                    if (!string.IsNullOrWhiteSpace(request.Logo))
-                    {
-                        artwork.Add(
-                            new Artwork
-                            {
-                                Path = request.Logo,
-                                ArtworkKind = ArtworkKind.Logo,
-                                DateAdded = DateTime.UtcNow,
-                                DateUpdated = DateTime.UtcNow
-                            });
-                    }
-
-                    var channel = new Channel(Guid.NewGuid())
-                    {
-                        Name = name,
-                        Number = number,
-                        FFmpegProfileId = ffmpegProfileId,
-                        StreamingMode = request.StreamingMode,
-                        Artwork = artwork,
-                        PreferredLanguageCode = preferredLanguageCode
-                    };
-
-                    foreach (int id in watermarkId)
-                    {
-                        channel.WatermarkId = id;
-                    }
-
-                    return channel;
-                });
-
-        private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
-            createChannel.NotEmpty(c => c.Name)
-                .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
-
-        private static Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
-            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(TvContext dbContext, CreateChannel createChannel)
-        {
-            Option<Channel> maybeExistingChannel = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
-            return maybeExistingChannel.Match<Validation<BaseError, string>>(
-                _ => BaseError.New("Channel number must be unique"),
-                () =>
-                {
-                    if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
-                    {
-                        return createChannel.Number;
-                    }
-
-                    return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-                });
-        }
-
-        private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel) =>
-            dbContext.FFmpegProfiles
-                .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => createChannel.FFmpegProfileId)
-                .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
-
-        private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel)
-        {
-            if (createChannel.WatermarkId is null)
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request),
+            await FFmpegProfileMustExist(dbContext, request),
+            ValidatePreferredAudioLanguage(request),
+            ValidatePreferredSubtitleLanguage(request),
+            await WatermarkMustExist(dbContext, request),
+            await FillerPresetMustExist(dbContext, request))
+        .Apply(
+            (
+                name,
+                number,
+                ffmpegProfileId,
+                preferredAudioLanguageCode,
+                preferredSubtitleLanguageCode,
+                watermarkId,
+                fillerPresetId) =>
             {
-                return Option<int>.None;
-            }
+                var artwork = new List<Artwork>();
+                if (!string.IsNullOrWhiteSpace(request.Logo))
+                {
+                    artwork.Add(
+                        new Artwork
+                        {
+                            Path = request.Logo,
+                            ArtworkKind = ArtworkKind.Logo,
+                            DateAdded = DateTime.UtcNow,
+                            DateUpdated = DateTime.UtcNow
+                        });
+                }
 
-            return await dbContext.ChannelWatermarks
-                .CountAsync(w => w.Id == createChannel.WatermarkId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => Optional(createChannel.WatermarkId))
-                .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+                var channel = new Channel(Guid.NewGuid())
+                {
+                    Name = name,
+                    Number = number,
+                    Group = request.Group,
+                    Categories = request.Categories,
+                    FFmpegProfileId = ffmpegProfileId,
+                    StreamingMode = request.StreamingMode,
+                    Artwork = artwork,
+                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                    PreferredAudioTitle = request.PreferredAudioTitle,
+                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
+                    SubtitleMode = request.SubtitleMode,
+                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
+                };
+
+                foreach (int id in watermarkId)
+                {
+                    channel.WatermarkId = id;
+                }
+
+                foreach (int id in fillerPresetId)
+                {
+                    channel.FallbackFillerId = id;
+                }
+
+                return channel;
+            });
+
+    private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
+        createChannel.NotEmpty(c => c.Name)
+            .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
+
+    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(CreateChannel createChannel) =>
+        Optional(createChannel.PreferredAudioLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred audio language code is invalid");
+
+    private static Validation<BaseError, string> ValidatePreferredSubtitleLanguage(CreateChannel createChannel) =>
+        Optional(createChannel.PreferredSubtitleLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred subtitle language code is invalid");
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        CreateChannel createChannel)
+    {
+        Option<Channel> maybeExistingChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
+        return maybeExistingChannel.Match<Validation<BaseError, string>>(
+            _ => BaseError.New("Channel number must be unique"),
+            () =>
+            {
+                if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
+                {
+                    return createChannel.Number;
+                }
+
+                return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+            });
+    }
+
+    private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel) =>
+        dbContext.FFmpegProfiles
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => createChannel.FFmpegProfileId)
+            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
+
+    private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel)
+    {
+        if (createChannel.WatermarkId is null)
+        {
+            return Option<int>.None;
         }
+
+        return await dbContext.ChannelWatermarks
+            .CountAsync(w => w.Id == createChannel.WatermarkId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.WatermarkId))
+            .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+    }
+
+    private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel)
+    {
+        if (createChannel.FallbackFillerId is null)
+        {
+            return Option<int>.None;
+        }
+
+        return await dbContext.FillerPresets
+            .Filter(fp => fp.FillerKind == FillerKind.Fallback)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.FallbackFillerId))
+            .Map(
+                o => o.ToValidation<BaseError>(
+                    $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
     }
 }

ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs

@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);
-}
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

@@ -1,9 +1,5 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,28 +1,23 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
 {
-    public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
-            (await ChannelMustExist(request))
-            .Map(DoDeletion)
-            .ToEither<Task>();
+    public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
+        (await ChannelMustExist(request))
+        .Map(DoDeletion)
+        .ToEither<Task>();
 
-        private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
+    private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
 
-        private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
-            (await _channelRepository.Get(deleteChannel.ChannelId))
-            .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
-            .Map(c => c.Id);
-    }
+    private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
+        (await _channelRepository.Get(deleteChannel.ChannelId))
+        .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
+        .Map(c => c.Id);
 }

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,18 +1,23 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record UpdateChannel
-    (
-        int ChannelId,
-        string Name,
-        string Number,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, ChannelViewModel>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record UpdateChannel
+(
+    int ChannelId,
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,121 +1,141 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Threading.Channels;
+using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
-    public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+    public UpdateChannelHandler(
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, ChannelViewModel>> Handle(
-            UpdateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
-        {
-            c.Name = update.Name;
-            c.Number = update.Number;
-            c.FFmpegProfileId = update.FFmpegProfileId;
-            c.PreferredLanguageCode = update.PreferredLanguageCode;
-            c.Artwork ??= new List<Artwork>();
-
-            if (!string.IsNullOrWhiteSpace(update.Logo))
-            {
-                Option<Artwork> maybeLogo =
-                    Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
-
-                maybeLogo.Match(
-                    artwork =>
-                    {
-                        artwork.Path = update.Logo;
-                        artwork.DateUpdated = DateTime.UtcNow;
-                    },
-                    () =>
-                    {
-                        var artwork = new Artwork
-                        {
-                            Path = update.Logo,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = DateTime.UtcNow,
-                            ArtworkKind = ArtworkKind.Logo
-                        };
-                        c.Artwork.Add(artwork);
-                    });
-            }
-            
-            c.StreamingMode = update.StreamingMode;
-            c.WatermarkId = update.WatermarkId;
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(c);
-        }
-
-        private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
-            (await ChannelMustExist(dbContext, request), ValidateName(request),
-                await ValidateNumber(dbContext, request),
-                ValidatePreferredLanguage(request))
-            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
-
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(
-            TvContext dbContext,
-            UpdateChannel updateChannel) =>
-            dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
-            updateChannel.NotEmpty(c => c.Name)
-                .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(
-            TvContext dbContext,
-            UpdateChannel updateChannel)
-        {
-            int matchId = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
-                .Match(c => c.Id, () => updateChannel.ChannelId);
-
-            if (matchId == updateChannel.ChannelId)
-            {
-                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
-                {
-                    return updateChannel.Number;
-                }
-
-                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-            }
-
-            return BaseError.New("Channel number must be unique");
-        }
-
-        private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
-            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
+        _workerChannel = workerChannel;
+        _dbContextFactory = dbContextFactory;
     }
+
+    public async Task<Either<BaseError, ChannelViewModel>> Handle(
+        UpdateChannel request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
+    }
+
+    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
+    {
+        c.Name = update.Name;
+        c.Number = update.Number;
+        c.Group = update.Group;
+        c.Categories = update.Categories;
+        c.FFmpegProfileId = update.FFmpegProfileId;
+        c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
+        c.PreferredAudioTitle = update.PreferredAudioTitle;
+        c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
+        c.SubtitleMode = update.SubtitleMode;
+        c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
+        c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
+        c.Artwork ??= new List<Artwork>();
+
+        if (!string.IsNullOrWhiteSpace(update.Logo))
+        {
+            Option<Artwork> maybeLogo =
+                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
+
+            maybeLogo.Match(
+                artwork =>
+                {
+                    artwork.Path = update.Logo;
+                    artwork.DateUpdated = DateTime.UtcNow;
+                },
+                () =>
+                {
+                    var artwork = new Artwork
+                    {
+                        Path = update.Logo,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow,
+                        ArtworkKind = ArtworkKind.Logo
+                    };
+                    c.Artwork.Add(artwork);
+                });
+        }
+
+        c.StreamingMode = update.StreamingMode;
+        c.WatermarkId = update.WatermarkId;
+        c.FallbackFillerId = update.FallbackFillerId;
+        await dbContext.SaveChangesAsync();
+
+        if (c.SubtitleMode != ChannelSubtitleMode.None)
+        {
+            Option<Playout> maybePlayout = await dbContext.Playouts
+                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id);
+
+            foreach (Playout playout in maybePlayout)
+            {
+                await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+            }
+        }
+
+        return ProjectToViewModel(c);
+    }
+
+    private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+        (await ChannelMustExist(dbContext, request), ValidateName(request),
+            await ValidateNumber(dbContext, request),
+            ValidatePreferredAudioLanguage(request))
+        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        UpdateChannel updateChannel) =>
+        dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
+        updateChannel.NotEmpty(c => c.Name)
+            .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        UpdateChannel updateChannel)
+    {
+        int matchId = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
+            .Match(c => c.Id, () => updateChannel.ChannelId);
+
+        if (matchId == updateChannel.ChannelId)
+        {
+            if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+            {
+                return updateChannel.Number;
+            }
+
+            return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+        }
+
+        return BaseError.New("Channel number must be unique");
+    }
+
+    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(UpdateChannel updateChannel) =>
+        Optional(updateChannel.PreferredAudioLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred audio language code is invalid");
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,28 +1,50 @@
-using System.Linq;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-            new(
-                channel.Id,
-                channel.Number,
-                channel.Name,
-                channel.FFmpegProfileId,
-                GetLogo(channel),
-                channel.PreferredLanguageCode,
-                channel.StreamingMode,
-                channel.WatermarkId);
+    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.Group,
+            channel.Categories,
+            channel.FFmpegProfileId,
+            GetLogo(channel),
+            channel.PreferredAudioLanguageCode,
+            channel.PreferredAudioTitle,
+            channel.StreamingMode,
+            channel.WatermarkId,
+            channel.FallbackFillerId,
+            channel.Playouts?.Count ?? 0,
+            channel.PreferredSubtitleLanguageCode,
+            channel.SubtitleMode,
+            channel.MusicVideoCreditsMode,
+            channel.MusicVideoCreditsTemplate);
 
-        private static string GetLogo(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-                .Match(a => a.Path, string.Empty);
+    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.FFmpegProfile.Name,
+            channel.PreferredAudioLanguageCode,
+            GetStreamingMode(channel));
 
-        private static string GetWatermark(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
-                .Match(a => a.Path, string.Empty);
-    }
+    private static string GetLogo(Channel channel) =>
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+            .Match(a => a.Path, string.Empty);
+
+    private static string GetStreamingMode(Channel channel) =>
+        channel.StreamingMode switch
+        {
+            StreamingMode.TransportStream => "MPEG-TS (Legacy)",
+            StreamingMode.TransportStreamHybrid => "MPEG-TS",
+            StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
+            StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
+            _ => throw new ArgumentOutOfRangeException()
+        };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Channels;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetAllChannels : IRequest<List<ChannelViewModel>>;
-}
+public record GetAllChannels : IRequest<List<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+public record GetAllChannelsForApi : IRequest<List<ChannelResponseModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

@@ -0,0 +1,21 @@
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsForApiHandler : IRequestHandler<GetAllChannelsForApi, List<ChannelResponseModel>>
+{
+    private readonly IChannelRepository _channelRepository;
+
+    public GetAllChannelsForApiHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+    public async Task<List<ChannelResponseModel>> Handle(
+        GetAllChannelsForApi request,
+        CancellationToken cancellationToken)
+    {
+        IEnumerable<Channel> channels = Optional(await _channelRepository.GetAll()).Flatten();
+        return channels.Map(ProjectToResponseModel).ToList();
+    }
+}

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -1,21 +1,14 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
-    public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-            Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
-    }
+    public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
+        Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
 }

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Channels;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelById(int Id) : IRequest<Option<ChannelViewModel>>;
-}
+public record GetChannelById(int Id) : IRequest<Option<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

@@ -1,20 +1,15 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
 {
-    public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
-            _channelRepository.Get(request.Id)
-                .MapT(ProjectToViewModel);
-    }
+    public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
+        _channelRepository.Get(request.Id)
+            .MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelByNumber(string ChannelNumber) : IRequest<Option<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByNumberHandler : IRequestHandler<GetChannelByNumber, Option<ChannelViewModel>>
+{
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelByNumberHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+    public Task<Option<ChannelViewModel>> Handle(GetChannelByNumber request, CancellationToken cancellationToken) =>
+        _channelRepository.GetByNumber(request.ChannelNumber).MapT(ProjectToViewModel);
+}

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelFramerate(string ChannelNumber) : IRequest<Option<int>>;

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -0,0 +1,113 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Extensions;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, Option<int>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILogger<GetChannelFramerateHandler> _logger;
+
+    public GetChannelFramerateHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILogger<GetChannelFramerateHandler> logger)
+    {
+        _dbContextFactory = dbContextFactory;
+        _logger = logger;
+    }
+
+    public async Task<Option<int>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        FFmpegProfile ffmpegProfile = await dbContext.Channels
+            .Filter(c => c.Number == request.ChannelNumber)
+            .Include(c => c.FFmpegProfile)
+            .Map(c => c.FFmpegProfile)
+            .SingleAsync(cancellationToken);
+
+        if (!ffmpegProfile.NormalizeFramerate)
+        {
+            return Option<int>.None;
+        }
+
+        // TODO: expand to check everything in collection rather than what's scheduled?
+        _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
+
+        List<Playout> playouts = await dbContext.Playouts
+            .Include(p => p.Items)
+            .ThenInclude(pi => pi.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MediaVersions)
+            .Include(p => p.Items)
+            .ThenInclude(pi => pi.MediaItem)
+            .ThenInclude(mi => (mi as Episode).MediaVersions)
+            .Include(p => p.Items)
+            .ThenInclude(pi => pi.MediaItem)
+            .ThenInclude(mi => (mi as Song).MediaVersions)
+            .Include(p => p.Items)
+            .ThenInclude(pi => pi.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+            .Include(p => p.Items)
+            .ThenInclude(pi => pi.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+            .Filter(p => p.Channel.Number == request.ChannelNumber)
+            .ToListAsync(cancellationToken);
+
+        var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
+            .Flatten()
+            .Map(mv => mv.RFrameRate)
+            .ToList();
+
+        var distinct = frameRates.Distinct().ToList();
+        if (distinct.Count > 1)
+        {
+            // TODO: something more intelligent than minimum framerate?
+            int result = frameRates.Map(ParseFrameRate).Min();
+            if (result < 24)
+            {
+                _logger.LogInformation(
+                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
+                    request.ChannelNumber,
+                    distinct,
+                    24,
+                    result);
+
+                return 24;
+            }
+
+            _logger.LogInformation(
+                "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
+                request.ChannelNumber,
+                distinct,
+                result);
+            return result;
+        }
+
+        _logger.LogInformation(
+            "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
+            request.ChannelNumber,
+            distinct[0]);
+        return None;
+    }
+
+    private int ParseFrameRate(string frameRate)
+    {
+        if (!int.TryParse(frameRate, out int fr))
+        {
+            string[] split = (frameRate ?? string.Empty).Split("/");
+            if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
+            {
+                fr = (int)Math.Round(left / (double)right);
+            }
+            else
+            {
+                fr = 24;
+            }
+        }
+
+        return fr;
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Iptv;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelGuide(string Scheme, string Host, string BaseUrl) : IRequest<ChannelGuide>;

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,20 +1,29 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
+using Microsoft.IO;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
 {
-    public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
+    private readonly IChannelRepository _channelRepository;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public GetChannelGuideHandler(
+        IChannelRepository channelRepository,
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager)
     {
-        private readonly IChannelRepository _channelRepository;
-
-        public GetChannelGuideHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
-
-        public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAllForGuide()
-                .Map(channels => new ChannelGuide(request.Scheme, request.Host, channels));
+        _channelRepository = channelRepository;
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
     }
+
+    public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAllForGuide()
+            .Map(
+                channels => new ChannelGuide(
+                    _recyclableMemoryStreamManager,
+                    request.Scheme,
+                    request.Host,
+                    request.BaseUrl,
+                    channels));
 }

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Hdhr;
-using MediatR;
+using ErsatzTV.Core.Hdhr;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelLineup(string Scheme, string Host) : IRequest<List<LineupItem>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelLineup(string Scheme, string Host) : IRequest<List<LineupItem>>;

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

@@ -1,22 +1,15 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Hdhr;
+using ErsatzTV.Core.Hdhr;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
 {
-    public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll()
-                .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
-    }
+    public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAll()
+            .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
 }

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutId.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelNameByPlayoutId(int PlayoutId) : IRequest<Option<string>>;

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

@@ -0,0 +1,24 @@
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelNameByPlayoutIdHandler : IRequestHandler<GetChannelNameByPlayoutId, Option<string>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }
+
+    public async Task<Option<string>> Handle(GetChannelNameByPlayoutId request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Playouts
+            .Include(p => p.Channel)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId)
+            .MapT(p => p.Channel.Name);
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -1,48 +1,50 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
-    public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
+
+    public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAll()
+            .Map(channels => EnsureMode(channels, request.Mode))
+            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, request.BaseUrl, channels));
+
+    private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
-        private readonly IChannelRepository _channelRepository;
-
-        public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
-            _channelRepository = channelRepository;
-
-        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)
         {
-            var result = new List<Channel>();
-            foreach (Channel channel in channels)
+            switch (mode.ToLowerInvariant())
             {
-                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;
-                }
+                case "segmenter":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
+                    result.Add(channel);
+                    break;
+                case "hls-direct":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
+                    result.Add(channel);
+                    break;
+                case "ts-legacy":
+                    channel.StreamingMode = StreamingMode.TransportStream;
+                    result.Add(channel);
+                    break;
+                case "ts":
+                    channel.StreamingMode = StreamingMode.TransportStreamHybrid;
+                    result.Add(channel);
+                    break;
+                default:
+                    result.Add(channel);
+                    break;
             }
-
-            return result;
         }
+
+        return result;
     }
 }

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -1,21 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
+using ErsatzTV.Core.Interfaces.Repositories;
 
-namespace ErsatzTV.Application.Configuration.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementByKey, Unit>
 {
-    public class SaveConfigElementByKeyHandler : MediatR.IRequestHandler<SaveConfigElementByKey, Unit>
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-
-        public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
-        {
-            await _configElementRepository.Upsert(request.Key, request.Value);
-            return Unit.Default;
-        }
+        await _configElementRepository.Upsert(request.Key, request.Value);
+        return Unit.Default;
     }
 }

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Configuration;
+
+public record UpdateGeneralSettings(GeneralSettingsViewModel GeneralSettings) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -0,0 +1,32 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Core;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly LoggingLevelSwitch _loggingLevelSwitch;
+
+    public UpdateGeneralSettingsHandler(
+        LoggingLevelSwitch loggingLevelSwitch,
+        IConfigElementRepository configElementRepository)
+    {
+        _loggingLevelSwitch = loggingLevelSwitch;
+        _configElementRepository = configElementRepository;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateGeneralSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.GeneralSettings);
+
+    private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.MinimumLogLevel);
+        _loggingLevelSwitch.MinimumLevel = generalSettings.MinimumLogLevel;
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -1,33 +1,31 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Configuration.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLibraryRefreshIntervalHandler :
+    IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
 {
-    public class UpdateLibraryRefreshIntervalHandler :
-        MediatR.IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateLibraryRefreshInterval request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval))
-                .Bind(v => v.ToEitherAsync());
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateLibraryRefreshInterval request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(
+                _ => _configElementRepository.Upsert(
+                    ConfigElementKey.LibraryRefreshInterval,
+                    request.LibraryRefreshInterval))
+            .Bind(v => v.ToEitherAsync());
 
-        private static 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 static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
+        Optional(request.LibraryRefreshInterval)
+            .Where(lri => lri is >= 0 and < 1_000_000)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
+            .AsTask();
 }

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettings.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Configuration;
+
+public record UpdatePlayoutSettings(PlayoutSettingsViewModel PlayoutSettings) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -0,0 +1,62 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdatePlayoutSettingsHandler : IRequestHandler<UpdatePlayoutSettings, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+    public UpdatePlayoutSettingsHandler(
+        IConfigElementRepository configElementRepository,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    {
+        _configElementRepository = configElementRepository;
+        _dbContextFactory = dbContextFactory;
+        _workerChannel = workerChannel;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdatePlayoutSettings request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Unit> validation = await Validate(request);
+        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.PlayoutSettings));
+    }
+
+    private async Task<Unit> ApplyUpdate(TvContext dbContext, PlayoutSettingsViewModel playoutSettings)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, playoutSettings.DaysToBuild);
+        await _configElementRepository.Upsert(
+            ConfigElementKey.PlayoutSkipMissingItems,
+            playoutSettings.SkipMissingItems);
+
+        // continue all playouts to proper number of days
+        List<Playout> playouts = await dbContext.Playouts
+            .Include(p => p.Channel)
+            .ToListAsync();
+        foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
+        {
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
+        }
+
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Unit>> Validate(UpdatePlayoutSettings request) =>
+        Optional(request.PlayoutSettings.DaysToBuild)
+            .Where(days => days > 0)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>("Days to build must be greater than zero")
+            .AsTask();
+}

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

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

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

@@ -0,0 +1,8 @@
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GeneralSettingsViewModel
+{
+    public LogEventLevel MinimumLogLevel { get; set; }
+}

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public class PlayoutSettingsViewModel
+{
+    public int DaysToBuild { get; set; }
+    public bool SkipMissingItems { get; set; }
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

@@ -1,22 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Configuration.Mapper;
 
-namespace ErsatzTV.Application.Configuration.Queries
+namespace ErsatzTV.Application.Configuration;
+
+public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
 {
-    public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<Option<ConfigElementViewModel>> Handle(
-            GetConfigElementByKey request,
-            CancellationToken cancellationToken) =>
-            _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
-    }
+    public Task<Option<ConfigElementViewModel>> Handle(
+        GetConfigElementByKey request,
+        CancellationToken cancellationToken) =>
+        _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Configuration;
+
+public record GetGeneralSettings : IRequest<GeneralSettingsViewModel>;

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, GeneralSettingsViewModel>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetGeneralSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
+    {
+        Option<LogEventLevel> maybeLogLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
+
+        return new GeneralSettingsViewModel
+        {
+            MinimumLogLevel = await maybeLogLevel.IfNoneAsync(LogEventLevel.Information)
+        };
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettings.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Configuration;
+
+public record GetPlayoutSettings : IRequest<PlayoutSettingsViewModel>;

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

@@ -0,0 +1,26 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetPlayoutSettingsHandler : IRequestHandler<GetPlayoutSettings, PlayoutSettingsViewModel>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetPlayoutSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<PlayoutSettingsViewModel> Handle(GetPlayoutSettings request, CancellationToken cancellationToken)
+    {
+        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
+
+        Option<bool> skipMissingItems =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems);
+
+        return new PlayoutSettingsViewModel
+        {
+            DaysToBuild = await daysToBuild.IfNoneAsync(2),
+            SkipMissingItems = await skipMissingItems.IfNoneAsync(false)
+        };
+    }
+}

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -0,0 +1,98 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Emby;
+
+public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchronizeEmbyLibraryById>,
+    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallEmbyLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizeEmbyLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-emby", request.EmbyLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        ISynchronizeEmbyLibraryById request)
+    {
+        return await dbContext.EmbyLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId)
+            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        ISynchronizeEmbyLibraryById request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+    }
+}

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

@@ -1,46 +1,41 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+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
+namespace ErsatzTV.Application.Emby;
+
+public class DisconnectEmbyHandler : IRequestHandler<DisconnectEmby, Either<BaseError, Unit>>
 {
-    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)
     {
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly IEntityLocker _entityLocker;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
+        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
+        _entityLocker = entityLocker;
+        _searchIndex = 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>();
 
-        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;
-        }
+        return Unit.Default;
     }
 }

ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -1,60 +1,56 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
 {
-    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)
     {
-        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);
+        _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

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -1,118 +1,111 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+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
+namespace ErsatzTV.Application.Emby;
+
+public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
 {
-    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)
     {
-        private readonly IEmbyApiClient _embyApiClient;
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
+        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
+        _embyApiClient = embyApiClient;
+        _logger = logger;
+        _searchIndex = searchIndex;
+    }
 
-        public SynchronizeEmbyLibrariesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbySecretStore embySecretStore,
-            IEmbyApiClient embyApiClient,
-            ILogger<SynchronizeEmbyLibrariesHandler> logger,
-            ISearchIndex 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)
+            .Where(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);
+
+        foreach (BaseError error in maybeLibraries.LeftToSeq())
         {
-            _mediaSourceRepository = mediaSourceRepository;
-            _embySecretStore = embySecretStore;
-            _embyApiClient = embyApiClient;
-            _logger = logger;
-            _searchIndex = searchIndex;
+            _logger.LogWarning(
+                "Unable to synchronize libraries from emby server {EmbyServer}: {Error}",
+                connectionParameters.EmbyMediaSource.ServerName,
+                error.Value);
         }
 
-        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)
+        foreach (List<EmbyLibrary> libraries in maybeLibraries.RightToSeq())
         {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active connection");
+            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();
+            var toUpdate = libraries
+                .Filter(l => toAdd.All(a => a.ItemId != l.ItemId) && toRemove.All(r => r.ItemId != l.ItemId)).ToList();
+            List<int> ids = await _mediaSourceRepository.UpdateLibraries(
+                connectionParameters.EmbyMediaSource.Id,
+                toAdd,
+                toRemove,
+                toUpdate);
+            if (ids.Any())
+            {
+                await _searchIndex.RemoveItems(ids);
+                _searchIndex.Commit();
+            }
         }
 
-        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");
-        }
+        return Unit.Default;
+    }
 
-        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; }
-        }
+    private record ConnectionParameters(
+        EmbyMediaSource EmbyMediaSource,
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
     }
 }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -1,181 +0,0 @@
-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 ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
-            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
-            {
-                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 ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
-            .Apply(
-                (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                    connectionParameters,
-                    embyLibrary,
-                    request.ForceScan,
-                    libraryRefreshInterval,
-                    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, int>> ValidateLibraryRefreshInterval() =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .FilterT(lri => lri > 0)
-                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private record RequestParameters(
-            ConnectionParameters ConnectionParameters,
-            EmbyLibrary Library,
-            bool ForceScan,
-            int LibraryRefreshInterval,
-            string FFprobePath);
-
-        private record ConnectionParameters(
-            EmbyMediaSource EmbyMediaSource,
-            EmbyConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
-    }
-}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

@@ -1,11 +1,7 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+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;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
+    IEmbyBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

@@ -1,42 +1,36 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class
+    UpdateEmbyLibraryPreferencesHandler : IRequestHandler<UpdateEmbyLibraryPreferences,
+        Either<BaseError, Unit>>
 {
-    public class
-        UpdateEmbyLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateEmbyLibraryPreferences,
-            Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public UpdateEmbyLibraryPreferencesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ISearchIndex searchIndex)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
+        _mediaSourceRepository = mediaSourceRepository;
+        _searchIndex = 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();
 
-        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);
 
-            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
-            await _mediaSourceRepository.EnableEmbyLibrarySync(toEnable);
-
-            return Unit.Default;
-        }
+        return Unit.Default;
     }
 }

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -1,55 +1,49 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathReplacements,
+    Either<BaseError, Unit>>
 {
-    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)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
 
-        public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        var incoming = request.PathReplacements.Map(Project).ToList();
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateEmbyPathReplacements request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(pms => MergePathReplacements(request, pms))
-                .Bind(v => v.ToEitherAsync());
+        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();
 
-        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."));
+        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

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

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

@@ -1,8 +1,12 @@
 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);
-}
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyLibraryViewModel(
+        int Id,
+        string Name,
+        LibraryMediaKind MediaKind,
+        bool ShouldSyncItems,
+        int MediaSourceId)
+    : LibraryViewModel("Emby", Id, Name, MediaKind, MediaSourceId);

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

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

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

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

ErsatzTV.Application/Emby/Mapper.cs

@@ -1,19 +1,18 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Emby
+namespace ErsatzTV.Application.Emby;
+
+internal static class Mapper
 {
-    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 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 EmbyLibraryViewModel ProjectToViewModel(EmbyLibrary library) =>
+        new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems, library.MediaSourceId);
 
-        internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
-            new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
-    }
+    internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
+        new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
 }

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

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