prep for release v25.3.1 [no ci]

* include docker-arm in unified image health check

* update

.config/dotnet-tools.json

@@ -3,16 +3,11 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2022.1.0",
+      "version": "2025.1.4",
       "commands": [
         "jb"
-      ]
-    },
-    "swashbuckle.aspnetcore.cli": {
-      "version": "5.6.2",
-      "commands": [
-        "swagger"
-      ]
+      ],
+      "rollForward": false
     }
   }
 }

.editorconfig

@@ -2,7 +2,7 @@
 [*]
 charset=utf-8
 end_of_line=lf
-trim_trailing_whitespace=false
+trim_trailing_whitespace=true
 insert_final_newline=false
 indent_style=space
 indent_size=4
@@ -83,3 +83,8 @@ tab_width=4
 [*.yml]
 indent_style = space
 indent_size = 2
+
+
+[*.cs]
+# disable CA1848: Use the LoggerMessage delegates`
+dotnet_diagnostic.ca1848.severity = none

.gitattributes

@@ -0,0 +1,8 @@
+# Auto detect text files and perform LF normalization
+*          text=auto
+
+*.cs       text diff=csharp
+*.cshtml   text diff=html
+*.csx      text diff=csharp
+*.sln      text eol=crlf
+*.csproj   text eol=crlf

.github/workflows/artifacts.yml

@@ -33,33 +33,23 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: macos-11
+          - os: macos-14
             kind: macOS
             target: osx-x64
-          - os: macos-11
+          - os: macos-14
             kind: macOS
             target: osx-arm64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         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
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -68,7 +58,7 @@ jobs:
         run: dotnet restore -r "${{ matrix.target}}"
 
       - name: Import Code-Signing Certificates
-        uses: Apple-Actions/import-codesign-certs@v1
+        uses: Apple-Actions/import-codesign-certs@v2
         with:
           p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
           p12-password: ${{ secrets.apple_developer_certificate_password }}
@@ -83,8 +73,8 @@ jobs:
         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
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -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 net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
 
       - name: Bundle
         shell: bash
@@ -112,18 +102,15 @@ jobs:
             --hide-extension "ErsatzTV.app" \
             --app-drop-link 600 185 \
             --skip-jenkins \
+            --no-internet-enable \
             "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 }}
+          xcrun notarytool submit ErsatzTV.dmg --apple-id "${{ secrets.ac_username }}" --password "${{ secrets.ac_password }}" --team-id 32MB98Q32R --wait
+          xcrun stapler staple ErsatzTV.dmg
 
       - name: Cleanup
         shell: bash
@@ -145,7 +132,7 @@ jobs:
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
-          prerelease: true
+          prerelease: false
           tag_name: ${{ inputs.release_tag }}
           files: |
             ${{ env.RELEASE_NAME }}.dmg
@@ -163,8 +150,11 @@ jobs:
             target: linux-x64
           - os: ubuntu-latest
             kind: linux
-            target: linux-arm
+            target: linux-musl-x64
           - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
+          - os: ubuntu-24.04-arm
             kind: linux
             target: linux-arm64
           - os: windows-latest
@@ -172,30 +162,14 @@ jobs:
             target: win-x64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         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
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -208,7 +182,7 @@ jobs:
         id: downloadffmpeg
         name: Download ffmpeg
         with:
-          url: "https://github.com/GyanD/codexffmpeg/releases/download/6.0/ffmpeg-6.0-full_build.7z"
+          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/7.1.1/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip"
           target: ffmpeg/
 
       - name: Build
@@ -220,8 +194,11 @@ jobs:
 
           # 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
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -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 net9.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          mkdir "$release_name"
+          mv scanner/* "$release_name/"
+          mv main/* "$release_name/"
 
           # Build Windows launcher
           if [ "${{ matrix.kind }}" == "windows" ]; then
@@ -245,9 +222,6 @@ jobs:
 
           # 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
@@ -259,10 +233,11 @@ jobs:
           assets: |
             *${{ matrix.target }}.zip
             *${{ matrix.target }}.tar.gz
+
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
-          prerelease: true
+          prerelease: false
           tag_name: ${{ inputs.release_tag }}
           files: |
             ${{ env.RELEASE_NAME }}.zip

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Extract Docker Tag
@@ -19,14 +19,14 @@ jobs:
           tag=$(git describe --tags --abbrev=0)
           tag2="${tag:1}"
           short=$(git rev-parse --short HEAD)
-          final="${tag2/beta/$short}"
+          final="${tag2}-${short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           short=$(git rev-parse --short HEAD)
-          final="${tag/beta/$short}"
+          final="${tag}-${short}"
           echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
           echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
     outputs:
@@ -34,7 +34,7 @@ jobs:
       artifacts_version: ${{ env.ARTIFACTS_VERSION }}
       info_version: ${{ env.INFO_VERSION }}
   build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
     needs: calculate_version
     with:
       release_tag: develop
@@ -46,8 +46,8 @@ jobs:
       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
+  build_images:
+    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:
       base_version: develop

.github/workflows/docker.yml

@@ -1,4 +1,4 @@
-name: Build & Publish to Docker Hub
+name: Build & Publish to Docker Hub
 on:
   workflow_call:
     inputs:
@@ -20,93 +20,122 @@ on:
       docker_hub_access_token:
         required: true
 jobs:
-  build_and_push:
-    name: Build & Publish
-    runs-on: ubuntu-latest
+  build_images:
+    name: Build ${{ matrix.name }} image
+    runs-on: ${{ matrix.os }}
     if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - name: base
+          - name: amd64
+            os: ubuntu-latest
             path: ''
-            suffix: ''
-            qemu: false
-          - name: nvidia
-            path: 'nvidia/'
-            suffix: '-nvidia'
-            qemu: false
-          - name: vaapi
-            path: 'vaapi/'
-            suffix: '-vaapi'
-            qemu: false
+            suffix: '-amd64'
+            platform: 'linux/amd64'
           - name: arm32v7
+            os: ubuntu-latest
             path: 'arm32v7/'
             suffix: '-arm'
-            qemu: true
+            platform: 'linux/arm/v7'
           - name: arm64
+            os: ubuntu-24.04-arm
             path: 'arm64/'
             suffix: '-arm64'
-            qemu: true
+            platform: 'linux/arm64'
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-        if: ${{ matrix.qemu == true }}
+        if: ${{ matrix.name == 'arm32v7' }}
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-        id: docker-buildx
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.docker_hub_username }}
           password: ${{ secrets.docker_hub_access_token }}
 
-      - name: Build and push
-        uses: docker/build-push-action@v3
+      - name: Log in to the Container registry
+        uses: docker/login-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' }}
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push
-        uses: docker/build-push-action@v3
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v5
         with:
-          builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
           file: ./docker/${{ matrix.path }}Dockerfile
           push: true
-          platforms: 'linux/arm64'
+          provenance: false
+          platforms: ${{ matrix.platform }}
           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' }}
+          outputs: |
+            type=image,name=jasongdove/ersatztv,name-canonical=true,push-by-digest=true
+            type=image,name=ghcr.io/ersatztv/ersatztv,name-canonical=true,push-by-digest=true
 
-      - name: Build and push
-        uses: docker/build-push-action@v3
+      - name: Save digest to artifact
+        run: echo ${{ steps.build.outputs.digest }} > digest.txt
+
+      - name: Upload digest artifact
+        uses: actions/upload-artifact@v4
         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' }}
+          name: digest-${{ matrix.name }}
+          path: digest.txt
+
+  merge_manifests:
+    name: Merge Manifests
+    runs-on: ubuntu-latest
+    needs: build_images
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.docker_hub_username }}
+          password: ${{ secrets.docker_hub_access_token }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download all digest artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: digests/
+
+      - name: Read digests from artifacts
+        id: digests
+        run: |
+          AMD64_HASH=$(cat digests/digest-amd64/digest.txt)
+          ARM32V7_HASH=$(cat digests/digest-arm32v7/digest.txt)
+          ARM64_HASH=$(cat digests/digest-arm64/digest.txt)
+
+          DOCKER_HUB_DIGESTS="jasongdove/ersatztv@${AMD64_HASH} jasongdove/ersatztv@${ARM64_HASH} jasongdove/ersatztv@${ARM32V7_HASH}"
+          GHCR_DIGESTS="ghcr.io/ersatztv/ersatztv@${AMD64_HASH} ghcr.io/ersatztv/ersatztv@${ARM64_HASH} ghcr.io/ersatztv/ersatztv@${ARM32V7_HASH}"
+
+          echo "docker_hub_digests=${DOCKER_HUB_DIGESTS}" >> $GITHUB_OUTPUT
+          echo "ghcr_digests=${GHCR_DIGESTS}" >> $GITHUB_OUTPUT
+
+      - name: Create and push manifests
+        run: |
+          docker manifest create jasongdove/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.base_version }}
+          docker manifest create jasongdove/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.tag_version }}
+
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}

.github/workflows/docs.yml

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

.github/workflows/issue-stale.yml

@@ -0,0 +1,27 @@
+name: 'Close stale issues'
+
+on:
+  schedule:
+    - cron: '30 1 * * *'
+  workflow_dispatch:
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          ascending: true
+          days-before-stale: 120
+          days-before-pr-stale: -1
+          days-before-close: 21
+          days-before-pr-close: -1
+          operations-per-run: 500
+          exempt-issue-labels: 'regression,security,roadmap,future,feature,enhancement,confirmed'
+          stale-issue-label: 'stale'
+          stale-issue-message: |-
+            This issue has gone 120 days without an update and will be closed within 21 days if there is no new activity. To prevent this issue from being closed, please confirm the issue has not already been fixed by providing updated examples or logs.
+
+            If you have any questions you can use one of several ways to [contact us](https://ersatztv.org).
+          close-issue-message: |-
+            This issue was closed due to inactivity.

.github/workflows/pr.yml

@@ -6,17 +6,12 @@ jobs:
     runs-on: windows-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 7.0.x
-
-      - name: Setup Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -31,50 +26,61 @@ jobs:
         run: dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
 
       - name: Build Windows
         run: |
           cd ErsatzTV-Windows
           cargo build --release --all-features
   build_and_test_linux:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: linux-x64
+          - os: ubuntu-latest
+            target: linux-musl-x64
+          - os: ubuntu-latest
+            target: linux-arm
+          - os: ubuntu-24.04-arm
+            target: linux-arm64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 7.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 
       - name: Install dependencies
-        run: dotnet restore
+        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
 
       - name: Prep project file
         run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
 
       - name: Build
-        run: dotnet build --configuration Release --no-restore
+        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
   build_and_test_mac:
-    runs-on: macos-11
+    runs-on: macos-14
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 7.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -89,4 +95,4 @@ jobs:
         run: dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal

.github/workflows/release.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Extract Docker Tag
@@ -16,7 +16,7 @@ jobs:
         run: |
           tag=$(git describe --tags --abbrev=0)
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-beta/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |
@@ -29,7 +29,7 @@ jobs:
       artifacts_version: ${{ env.ARTIFACTS_VERSION }}
       info_version: ${{ env.INFO_VERSION }}
   build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
     needs: calculate_version
     with:
       release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
@@ -41,8 +41,8 @@ jobs:
       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
+  build_images:
+    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:
       base_version: latest

.github/workflows/vue-lint.yml

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

@@ -40,6 +40,7 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+scripts/download-test-content.sh
 
 docker-compose.override.yml
 

.gitmodules

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

Directory.Build.props

@@ -1,5 +1,6 @@
 <Project>
     <PropertyGroup>
         <InformationalVersion>develop</InformationalVersion>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     </PropertyGroup>
 </Project>

ErsatzTV-Windows/Cargo.lock

@@ -173,6 +173,7 @@ version = "0.1.0"
 dependencies = [
  "process_path",
  "special-folder",
+ "static_vcruntime",
  "tray-item",
  "windows",
  "windres",
@@ -769,6 +770,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "static_vcruntime"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "954e3e877803def9dc46075bf4060147c55cd70db97873077232eae0269dc89b"
+
 [[package]]
 name = "strum"
 version = "0.24.1"

ErsatzTV-Windows/Cargo.toml

@@ -17,3 +17,4 @@ features = [
 
 [build-dependencies]
 windres = "*"
+static_vcruntime = "2.0"

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/src/main.rs

@@ -1,6 +1,7 @@
 #![windows_subsystem = "windows"]
 
 use special_folder::SpecialFolder;
+use std::env;
 use std::fs;
 use std::os::windows::process::CommandExt;
 use std::process::Child;
@@ -21,11 +22,16 @@ fn main() {
     let (tx, rx) = mpsc::channel();
 
     tray.add_menu_item("Launch Web UI", || {
+        let ui_port = env::var("ETV_UI_PORT")
+            .ok()
+            .and_then(|val| val.parse::<u16>().ok())
+            .unwrap_or(8409);
+
         let _ = Command::new("cmd")
             .creation_flags(CREATE_NO_WINDOW)
             .arg("/C")
             .arg("start")
-            .arg("http://localhost:8409")
+            .arg(format!("http://localhost:{}", ui_port))
             .stdin(Stdio::null())
             .stdout(Stdio::null())
             .stderr(Stdio::null())
@@ -43,10 +49,7 @@ fn main() {
             None => {}
             Some(folder) => {
                 fs::create_dir_all(folder).unwrap();
-                let _ = Command::new("cmd")
-                    .creation_flags(CREATE_NO_WINDOW)
-                    .arg("/C")
-                    .arg("start")
+                let _ = Command::new("explorer.exe")
                     .arg(folder)
                     .stdin(Stdio::null())
                     .stdout(Stdio::null())

ErsatzTV.Application/.editorconfig

@@ -0,0 +1,5 @@
+[*.cs]
+# disable CA1711: Identifiers should not have incorrect suffix
+dotnet_diagnostic.ca1711.severity = none
+# disable CA1848: Use the LoggerMessage delegates
+dotnet_diagnostic.ca1848.severity = none

ErsatzTV.Application/Artists/Mapper.cs

@@ -29,12 +29,12 @@ internal static class Mapper
         CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
 
         return languages
-            .Distinct()
-            .Map(
-                lang => allCultures.Filter(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
-            .Sequence()
+            .Map(lang => allCultures.Filter(ci => string.Equals(
+                ci.ThreeLetterISOLanguageName,
+                lang,
+                StringComparison.OrdinalIgnoreCase)))
             .Flatten()
+            .Distinct()
             .ToList();
     }
 }

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -10,10 +10,7 @@ public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMed
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-    public GetAllArtistsHandler(IDbContextFactory<TvContext> dbContextFactory)
-    {
-        _dbContextFactory = dbContextFactory;
-    }
+    public GetAllArtistsHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
 
     public async Task<List<NamedMediaItemViewModel>> Handle(
         GetAllArtists request,
@@ -24,7 +21,7 @@ public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMed
         List<Artist> allArtists = await dbContext.Artists
             .AsNoTracking()
             .Include(a => a.ArtistMetadata)
-            .ToListAsync(cancellationToken: cancellationToken);
+            .ToListAsync(cancellationToken);
 
         return allArtists.Bind(a => ProjectArtist(a)).ToList();
     }

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -24,7 +24,7 @@ public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<Artist
             async artist =>
             {
                 List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
+                List<string> languageCodes = await _searchRepository.GetAllThreeLetterLanguageCodes(mediaCodes);
                 return ProjectToViewModel(artist, languageCodes);
             },
             () => Task.FromResult(Option<ArtistViewModel>.None));

ErsatzTV.Application/Artworks/ArtworkContentTypeModel.cs

@@ -0,0 +1,17 @@
+using System.Net;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+public record ArtworkContentTypeModel(string Path, string ContentType)
+{
+    public static readonly ArtworkContentTypeModel None = new(string.Empty, string.Empty);
+
+    public bool IsExternalUrl => Artwork.IsExternalUrl(Path);
+
+    public bool HasContentType => !string.IsNullOrWhiteSpace(ContentType);
+
+    public string UrlWithContentType => string.IsNullOrWhiteSpace(ContentType)
+        ? Path
+        : $"{Path}?contentType={WebUtility.UrlEncode(ContentType)}";
+}

ErsatzTV.Application/Artworks/Queries/GetArtwork.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+public record GetArtwork(int Id) : IRequest<Either<BaseError, Artwork>>;

ErsatzTV.Application/Artworks/Queries/GetArtworkHandler.cs

@@ -0,0 +1,42 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetArtwork, Either<BaseError, Artwork>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Artwork>> Handle(
+        GetArtwork request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            Option<Artwork> artwork = await dbContext.Artwork
+                .AsNoTracking()
+                .SelectOneAsync(a => a.Id, a => a.Id == request.Id)
+                .MapT(Project);
+
+            return artwork.ToEither(BaseError.New("Artwork not found"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private static Artwork Project(Artwork artwork) =>
+        new()
+        {
+            Id = artwork.Id,
+            Path = artwork.Path,
+            ArtworkKind = artwork.ArtworkKind
+        };
+}

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,4 +1,6 @@
-using ErsatzTV.Core.Domain;
+using System.Net;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -9,9 +11,12 @@ public record ChannelViewModel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -19,4 +24,9 @@ public record ChannelViewModel(
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate);
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelActiveMode ActiveMode)
+{
+    public string WebEncodedName => WebUtility.UrlEncode(Name);
+}

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,22 +1,27 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record CreateChannel
-(
+public record CreateChannel(
     string Name,
     string Number,
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, CreateChannelResult>>;
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelActiveMode ActiveMode) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,61 +1,69 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
 
-public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+public class CreateChannelHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : 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)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         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)
+    private async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
     {
         await dbContext.Channels.AddAsync(channel);
         await dbContext.SaveChangesAsync();
+        searchTargets.SearchTargetsChanged();
+        await workerChannel.WriteAsync(new RefreshChannelList());
         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),
-            ValidatePreferredAudioLanguage(request),
-            ValidatePreferredSubtitleLanguage(request),
             await WatermarkMustExist(dbContext, request),
             await FillerPresetMustExist(dbContext, request))
-        .Apply(
-            (
+        .Apply((
             name,
             number,
             ffmpegProfileId,
-                preferredAudioLanguageCode,
-                preferredSubtitleLanguageCode,
             watermarkId,
             fillerPresetId) =>
         {
             var artwork = new List<Artwork>();
-                if (!string.IsNullOrWhiteSpace(request.Logo))
+            if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
             {
+                string logo = request.Logo.Path;
+                if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+                {
+                    logo = logo.Replace("iptv/logos/", string.Empty);
+                }
+
                 artwork.Add(
                     new Artwork
                     {
-                            Path = request.Logo,
+                        Path = logo,
                         ArtworkKind = ArtworkKind.Logo,
+                        OriginalContentType = !string.IsNullOrEmpty(request.Logo.ContentType)
+                            ? request.Logo.ContentType
+                            : null,
                         DateAdded = DateTime.UtcNow,
                         DateUpdated = DateTime.UtcNow
                     });
@@ -68,14 +76,19 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                 Group = request.Group,
                 Categories = request.Categories,
                 FFmpegProfileId = ffmpegProfileId,
+                ProgressMode = request.ProgressMode,
                 StreamingMode = request.StreamingMode,
                 Artwork = artwork,
-                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                StreamSelectorMode = request.StreamSelectorMode,
+                StreamSelector = request.StreamSelector,
+                PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
                 PreferredAudioTitle = request.PreferredAudioTitle,
-                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
+                PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
                 SubtitleMode = request.SubtitleMode,
                 MusicVideoCreditsMode = request.MusicVideoCreditsMode,
-                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
+                MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
+                SongVideoMode = request.SongVideoMode,
+                ActiveMode = request.ActiveMode
             };
 
             foreach (int id in watermarkId)
@@ -95,20 +108,6 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
         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)
@@ -170,8 +169,7 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.FallbackFillerId))
-            .Map(
-                o => o.ToValidation<BaseError>(
+            .Map(o => o.ToValidation<BaseError>(
                 $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
     }
 }

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Channels;
 
-public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
+public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,23 +1,66 @@
-using ErsatzTV.Core;
-using ErsatzTV.Core.Interfaces.Repositories;
+using System.Threading.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
 
-public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
+public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Unit>>
 {
-    private readonly IChannelRepository _channelRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ISearchTargets _searchTargets;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
-    public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public DeleteChannelHandler(
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILocalFileSystem localFileSystem,
+        ISearchTargets searchTargets)
+    {
+        _workerChannel = workerChannel;
+        _dbContextFactory = dbContextFactory;
+        _localFileSystem = localFileSystem;
+        _searchTargets = searchTargets;
+    }
 
-    public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
-        (await ChannelMustExist(request))
-        .Map(DoDeletion)
-        .ToEither<Task>();
+    public async Task<Either<BaseError, Unit>> Handle(DeleteChannel request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request);
+        return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
+    }
 
-    private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
+    private async Task<Unit> DoDeletion(TvContext dbContext, Channel channel, CancellationToken cancellationToken)
+    {
+        dbContext.Channels.Remove(channel);
+        await dbContext.SaveChangesAsync(cancellationToken);
 
-    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);
+        _searchTargets.SearchTargetsChanged();
+
+        // delete channel data from channel guide cache
+        string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
+        if (_localFileSystem.FileExists(cacheFile))
+        {
+            File.Delete(cacheFile);
+        }
+
+        // refresh channel list to remove channel that has no playout
+        await _workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        DeleteChannel deleteChannel)
+    {
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId);
+        return maybeChannel.ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.");
+    }
 }

ErsatzTV.Application/Channels/Commands/RefreshChannelData.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record RefreshChannelData(string ChannelNumber) : IRequest, IBackgroundServiceRequest;

ErsatzTV.Application/Channels/Commands/RefreshChannelList.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record RefreshChannelList : IRequest, IBackgroundServiceRequest;

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -0,0 +1,147 @@
+using System.Data.Common;
+using System.Net;
+using System.Xml;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Iptv;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.IO;
+using Scriban;
+using Scriban.Runtime;
+using WebMarkupMin.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<RefreshChannelListHandler> _logger;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public RefreshChannelListHandler(
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILocalFileSystem localFileSystem,
+        ILogger<RefreshChannelListHandler> logger)
+    {
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _dbContextFactory = dbContextFactory;
+        _localFileSystem = localFileSystem;
+        _logger = logger;
+    }
+
+    public async Task Handle(RefreshChannelList request, CancellationToken cancellationToken)
+    {
+        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "channel.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
+        }
+
+        // fail if file doesn't exist
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate channel list without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return;
+        }
+
+        var minifier = new XmlMinifier(
+            new XmlMinificationSettings
+            {
+                MinifyWhitespace = true,
+                RemoveXmlComments = true,
+                CollapseTagsWithoutContent = true
+            });
+
+        string text = await File.ReadAllTextAsync(templateFileName, cancellationToken);
+        var template = Template.Parse(text, templateFileName);
+        var templateContext = new XmlTemplateContext();
+
+        await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+        await using var xml = XmlWriter.Create(
+            ms,
+            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+        await foreach (ChannelResult channel in GetChannels(dbContext).WithCancellation(cancellationToken))
+        {
+            bool hasLogo = !string.IsNullOrWhiteSpace(channel.ArtworkPath);
+            bool hasExternalLogo = hasLogo && Artwork.IsExternalUrl(channel.ArtworkPath);
+
+            var data = new
+            {
+                ChannelId = ChannelIdentifier.FromNumber(channel.Number),
+                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(channel.Number),
+                ChannelNumber = channel.Number,
+                ChannelName = channel.Name,
+                ChannelCategories = GetCategories(channel.Categories),
+                ChannelHasExternalArtwork = hasExternalLogo,
+                ChannelHasArtwork = hasLogo,
+                ChannelArtworkPath = channel.ArtworkPath,
+                ChannelNameEncoded = WebUtility.UrlEncode(channel.Name)
+            };
+
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
+
+            string result = await template.RenderAsync(templateContext);
+
+            MarkupMinificationResult minified = minifier.Minify(result);
+            await xml.WriteRawAsync(minified.MinifiedContent);
+        }
+
+        await xml.FlushAsync();
+
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        File.Move(tempFile, targetFile, true);
+    }
+
+    private static async IAsyncEnumerable<ChannelResult> GetChannels(TvContext dbContext)
+    {
+        const string QUERY = @"select C.Number, C.Name, C.Categories, A.Path as ArtworkPath
+                               from Channel C
+                               left outer join Artwork A on C.Id = A.ChannelId and A.ArtworkKind = 2
+                               where C.Id in (select ChannelId from Playout) and C.ActiveMode = 0
+                               order by CAST(C.Number as double)";
+        // TODO: this needs to be fixed for sqlite/mariadb
+
+        await using var reader = (DbDataReader)await dbContext.Connection.ExecuteReaderAsync(QUERY);
+        Func<DbDataReader, ChannelResult> rowParser = reader.GetRowParser<ChannelResult>();
+
+        while (await reader.ReadAsync())
+        {
+            yield return rowParser(reader);
+        }
+
+        while (await reader.NextResultAsync())
+        {
+        }
+    }
+
+    private static List<string> GetCategories(string categories) =>
+        (categories ?? string.Empty).Split(',')
+        .Map(s => s.Trim())
+        .Filter(s => !string.IsNullOrWhiteSpace(s))
+        .Distinct()
+        .ToList();
+
+    // ReSharper disable once ClassNeverInstantiated.Local
+    private sealed record ChannelResult(string Number, string Name, string Categories, string ArtworkPath);
+}

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,23 +1,28 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record UpdateChannel
-(
+public record UpdateChannel(
     int ChannelId,
     string Name,
     string Number,
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, ChannelViewModel>>;
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelActiveMode ActiveMode) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,9 +1,9 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -12,24 +12,17 @@ using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
 
-public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
-{
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
-
-    public UpdateChannelHandler(
+public class UpdateChannelHandler(
     ChannelWriter<IBackgroundServiceRequest> workerChannel,
-        IDbContextFactory<TvContext> dbContextFactory)
-    {
-        _workerChannel = workerChannel;
-        _dbContextFactory = dbContextFactory;
-    }
-
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+{
     public async Task<Either<BaseError, ChannelViewModel>> Handle(
         UpdateChannel request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(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));
     }
@@ -41,43 +34,72 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
+        c.StreamSelectorMode = update.StreamSelectorMode;
+        c.StreamSelector = update.StreamSelector;
         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>();
+        c.SongVideoMode = update.SongVideoMode;
+        c.ActiveMode = update.ActiveMode;
+        c.Artwork ??= [];
 
-        if (!string.IsNullOrWhiteSpace(update.Logo))
+        if (!string.IsNullOrWhiteSpace(update.Logo?.Path))
         {
-            Option<Artwork> maybeLogo =
-                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
+            string logo = update.Logo.Path;
+            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+            {
+                logo = logo.Replace("iptv/logos/", string.Empty);
+            }
 
-            maybeLogo.Match(
-                artwork =>
+            Option<Artwork> maybeLogo = c.Artwork.Where(a => a.ArtworkKind == ArtworkKind.Logo).HeadOrNone();
+            foreach (Artwork artwork in maybeLogo)
             {
-                    artwork.Path = update.Logo;
+                artwork.Path = logo;
+                artwork.OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                    ? update.Logo.ContentType
+                    : null;
                 artwork.DateUpdated = DateTime.UtcNow;
-                },
-                () =>
+            }
+
+            if (maybeLogo.IsNone)
             {
                 var artwork = new Artwork
                 {
-                        Path = update.Logo,
+                    Path = logo,
+                    OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                        ? update.Logo.ContentType
+                        : null,
                     DateAdded = DateTime.UtcNow,
                     DateUpdated = DateTime.UtcNow,
                     ArtworkKind = ArtworkKind.Logo
                 };
                 c.Artwork.Add(artwork);
-                });
+            }
+        }
+        else
+        {
+            await dbContext.Entry(c)
+                .Collection(channel => channel.Artwork)
+                .LoadAsync();
+
+            foreach (Artwork artwork in c.Artwork.Where(x => x.ArtworkKind is ArtworkKind.Logo).ToList())
+            {
+                c.Artwork.Remove(artwork);
+                dbContext.Artwork.Remove(artwork);
+            }
         }
 
+        c.ProgressMode = update.ProgressMode;
         c.StreamingMode = update.StreamingMode;
         c.WatermarkId = update.WatermarkId;
         c.FallbackFillerId = update.FallbackFillerId;
         await dbContext.SaveChangesAsync();
 
+        searchTargets.SearchTargetsChanged();
+
         if (c.SubtitleMode != ChannelSubtitleMode.None)
         {
             Option<Playout> maybePlayout = await dbContext.Playouts
@@ -85,18 +107,19 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
 
             foreach (Playout playout in maybePlayout)
             {
-                await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
             }
         }
 
+        await workerChannel.WriteAsync(new RefreshChannelList());
+
         return ProjectToViewModel(c);
     }
 
-    private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+    private static 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);
+            await ValidateNumber(dbContext, request))
+        .Apply((channelToUpdate, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
@@ -131,11 +154,4 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
 
         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,4 +1,5 @@
-using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -14,8 +15,11 @@ internal static class Mapper
             channel.Categories,
             channel.FFmpegProfileId,
             GetLogo(channel),
+            channel.StreamSelectorMode,
+            channel.StreamSelector,
             channel.PreferredAudioLanguageCode,
             channel.PreferredAudioTitle,
+            channel.ProgressMode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
@@ -23,7 +27,9 @@ internal static class Mapper
             channel.PreferredSubtitleLanguageCode,
             channel.SubtitleMode,
             channel.MusicVideoCreditsMode,
-            channel.MusicVideoCreditsTemplate);
+            channel.MusicVideoCreditsTemplate,
+            channel.SongVideoMode,
+            channel.ActiveMode);
 
     internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
         new(
@@ -34,9 +40,27 @@ internal static class Mapper
             channel.PreferredAudioLanguageCode,
             GetStreamingMode(channel));
 
-    private static string GetLogo(Channel channel) =>
-        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-            .Match(a => a.Path, string.Empty);
+    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
+        new(resolution.Height, resolution.Width);
+
+    internal static ResolutionAndBitrateViewModel ProjectToViewModel(Resolution resolution, int bitrate) =>
+        new(resolution.Height, resolution.Width, bitrate);
+
+    private static ArtworkContentTypeModel GetLogo(Channel channel)
+    {
+        Option<Artwork> maybeArtwork = channel.Artwork
+            .Where(a => a.ArtworkKind == ArtworkKind.Logo)
+            .HeadOrNone();
+
+        foreach (Artwork artwork in maybeArtwork)
+        {
+            return artwork.IsExternalUrl()
+                ? new ArtworkContentTypeModel(artwork.Path, string.Empty)
+                : new ArtworkContentTypeModel($"iptv/logos/{artwork.Path}", artwork.OriginalContentType);
+        }
+
+        return ArtworkContentTypeModel.None;
+    }
 
     private static string GetStreamingMode(Channel channel) =>
         channel.StreamingMode switch
@@ -45,6 +69,7 @@ internal static class Mapper
             StreamingMode.TransportStreamHybrid => "MPEG-TS",
             StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
             StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
-            _ => throw new ArgumentOutOfRangeException()
+            StreamingMode.HttpLiveStreamingSegmenterV2 => "HLS Segmenter V2",
+            _ => throw new ArgumentOutOfRangeException(nameof(channel))
         };
 }

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

@@ -3,13 +3,10 @@ using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
+public class GetChannelByIdHandler(IChannelRepository channelRepository)
+    : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
 {
-    private readonly IChannelRepository _channelRepository;
-
-    public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
-
     public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
-        _channelRepository.Get(request.Id)
+        channelRepository.GetChannel(request.Id)
             .MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -86,10 +86,20 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
             return result;
         }
 
+        if (distinct.Count != 0)
+        {
             _logger.LogInformation(
                 "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
                 request.ChannelNumber,
                 distinct[0]);
+        }
+        else
+        {
+            _logger.LogInformation(
+                "No content on channel {ChannelNumber} has frame rate information; will not normalize",
+                request.ChannelNumber);
+        }
+
         return None;
     }
 

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,29 +1,87 @@
-using ErsatzTV.Core.Interfaces.Repositories;
+using System.Collections.Immutable;
+using System.Text;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Iptv;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.IO;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
+public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
 {
-    private readonly IChannelRepository _channelRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
 
     public GetChannelGuideHandler(
-        IChannelRepository channelRepository,
-        RecyclableMemoryStreamManager recyclableMemoryStreamManager)
+        IDbContextFactory<TvContext> dbContextFactory,
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        ILocalFileSystem localFileSystem)
     {
-        _channelRepository = channelRepository;
+        _dbContextFactory = dbContextFactory;
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _localFileSystem = localFileSystem;
     }
 
-    public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAllForGuide()
-            .Map(
-                channels => new ChannelGuide(
-                    _recyclableMemoryStreamManager,
-                    request.Scheme,
-                    request.Host,
-                    request.BaseUrl,
-                    channels));
+    public async Task<Either<BaseError, ChannelGuide>> Handle(
+        GetChannelGuide request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        var inactiveChannelNumbers = dbContext.Channels
+            .Where(c => c.ActiveMode != ChannelActiveMode.Active)
+            .Select(c => c.Number)
+            .AsEnumerable()
+            .Select(n => $"{n}.xml")
+            .ToImmutableHashSet();
+
+        string channelsFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        if (!_localFileSystem.FileExists(channelsFile))
+        {
+            return BaseError.New($"Required file {channelsFile} is missing");
+        }
+
+        long mtime = File.GetLastWriteTime(channelsFile).Ticks;
+
+        var accessTokenUri = $"?v={mtime}";
+        if (!string.IsNullOrWhiteSpace(request.AccessToken))
+        {
+            accessTokenUri += $"&amp;access_token={request.AccessToken}";
+        }
+
+        string channelsFragment = await File.ReadAllTextAsync(channelsFile, Encoding.UTF8, cancellationToken);
+
+        // TODO: is regex faster?
+        channelsFragment = channelsFragment
+            .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+            .Replace("{AccessTokenUri}", accessTokenUri);
+
+        var channelDataFragments = new Dictionary<string, string>();
+
+        foreach (string fileName in _localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
+        {
+            if (fileName.Contains("channels"))
+            {
+                continue;
+            }
+
+            if (inactiveChannelNumbers.Contains(Path.GetFileName(fileName)))
+            {
+                continue;
+            }
+
+            string channelDataFragment = await File.ReadAllTextAsync(fileName, Encoding.UTF8, cancellationToken);
+
+            channelDataFragment = channelDataFragment
+                .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+                .Replace("{AccessTokenUri}", accessTokenUri);
+
+            channelDataFragments.Add(Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
+        }
+
+        return new ChannelGuide(_recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
+    }
 }

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core.Hdhr;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Hdhr;
 using ErsatzTV.Core.Interfaces.Repositories;
 
 namespace ErsatzTV.Application.Channels;
@@ -11,5 +12,6 @@ public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<Li
 
     public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
         _channelRepository.GetAll()
-            .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
+            .Map(channels => channels.Where(c => c.ActiveMode is ChannelActiveMode.Active)
+                .Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
 }

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

@@ -8,10 +8,8 @@ public class GetChannelNameByPlayoutIdHandler : IRequestHandler<GetChannelNameBy
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-    public GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
-    {
+    public GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
         _dbContextFactory = dbContextFactory;
-    }
 
     public async Task<Option<string>> Handle(GetChannelNameByPlayoutId request, CancellationToken cancellationToken)
     {

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

@@ -1,5 +1,11 @@
-using ErsatzTV.Core.Iptv;
+using ErsatzTV.Core.Iptv;
 
 namespace ErsatzTV.Application.Channels;
 
-public record GetChannelPlaylist(string Scheme, string Host, string BaseUrl, string Mode) : IRequest<ChannelPlaylist>;
+public record GetChannelPlaylist(
+    string Scheme,
+    string Host,
+    string BaseUrl,
+    string Mode,
+    string UserAgent,
+    string AccessToken) : IRequest<ChannelPlaylist>;

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -1,4 +1,4 @@
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
 
@@ -14,19 +14,34 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
     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));
+            .Map(channels => new ChannelPlaylist(
+                request.Scheme,
+                request.Host,
+                request.BaseUrl,
+                channels,
+                request.UserAgent,
+                request.AccessToken));
 
     private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
         var result = new List<Channel>();
         foreach (Channel channel in channels)
         {
+            if (channel.ActiveMode is not ChannelActiveMode.Active)
+            {
+                continue;
+            }
+
             switch (mode.ToLowerInvariant())
             {
                 case "segmenter":
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
                     result.Add(channel);
                     break;
+                case "segmenter-v2":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenterV2;
+                    result.Add(channel);
+                    break;
                 case "hls-direct":
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                     result.Add(channel);

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrateHandler.cs

@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelResolutionAndBitrate, Option<ResolutionAndBitrateViewModel>>
+{
+    public async Task<Option<ResolutionAndBitrateViewModel>> Handle(
+        GetChannelResolutionAndBitrate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .AsNoTracking()
+            .Include(c => c.FFmpegProfile)
+            .ThenInclude(ff => ff.Resolution)
+            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber);
+
+        return maybeChannel.Map(c => Mapper.ProjectToViewModel(
+            c.FFmpegProfile.Resolution,
+            (int)((c.FFmpegProfile.VideoBitrate * 1000 + c.FFmpegProfile.AudioBitrate * 1000) * 1.2)));
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectors.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelStreamSelectors : IRequest<List<string>>;

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectorsHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelStreamSelectorsHandler(ILocalFileSystem localFileSystem)
+    : IRequestHandler<GetChannelStreamSelectors, List<string>>
+{
+    public Task<List<string>> Handle(GetChannelStreamSelectors request, CancellationToken cancellationToken) =>
+        localFileSystem.ListFiles(FileSystemLayout.ChannelStreamSelectorsFolder)
+            .Map(Path.GetFileName)
+            .ToList()
+            .AsTask();
+}

ErsatzTV.Application/Channels/ResolutionAndBitrateViewModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record ResolutionAndBitrateViewModel(int Height, int Width, int Bitrate);

ErsatzTV.Application/Channels/ResolutionViewModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record ResolutionViewModel(int Height, int Width);

ErsatzTV.Application/Channels/XmlTemplateContext.cs

@@ -0,0 +1,14 @@
+using System.Net;
+using Scriban;
+using Scriban.Parsing;
+
+namespace ErsatzTV.Application.Channels;
+
+public class XmlTemplateContext : TemplateContext
+{
+    public override TemplateContext Write(SourceSpan span, object textAsObject)
+        => base.Write(span, textAsObject is string text ? WebUtility.HtmlEncode(text) : textAsObject);
+
+    public override ValueTask<TemplateContext> WriteAsync(SourceSpan span, object textAsObject)
+        => base.WriteAsync(span, textAsObject is string text ? WebUtility.HtmlEncode(text) : textAsObject);
+}

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -9,8 +9,6 @@ public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementBy
     public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
         _configElementRepository = configElementRepository;
 
-    public async Task Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
-    {
+    public async Task Handle(SaveConfigElementByKey request, CancellationToken cancellationToken) =>
         await _configElementRepository.Upsert(request.Key, request.Value);
-    }
 }

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -1,32 +0,0 @@
-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/UpdateLibraryRefreshIntervalHandler.cs

@@ -16,8 +16,7 @@ public class UpdateLibraryRefreshIntervalHandler :
         UpdateLibraryRefreshInterval request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(
-                _ => _configElementRepository.Upsert(
+            .MapT(_ => _configElementRepository.Upsert(
                 ConfigElementKey.LibraryRefreshInterval,
                 request.LibraryRefreshInterval))
             .Bind(v => v.ToEitherAsync());

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettingsHandler.cs

@@ -0,0 +1,51 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSettings, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly LoggingLevelSwitches _loggingLevelSwitches;
+
+    public UpdateLoggingSettingsHandler(
+        LoggingLevelSwitches loggingLevelSwitches,
+        IConfigElementRepository configElementRepository)
+    {
+        _loggingLevelSwitches = loggingLevelSwitches;
+        _configElementRepository = configElementRepository;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateLoggingSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.LoggingSettings);
+
+    private async Task<Unit> ApplyUpdate(LoggingSettingsViewModel loggingSettings)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, loggingSettings.DefaultMinimumLogLevel);
+        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = loggingSettings.DefaultMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScanning,
+            loggingSettings.ScanningMinimumLogLevel);
+        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = loggingSettings.ScanningMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScheduling,
+            loggingSettings.SchedulingMinimumLogLevel);
+        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = loggingSettings.SchedulingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelStreaming,
+            loggingSettings.StreamingMinimumLogLevel);
+        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = loggingSettings.StreamingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelHttp,
+            loggingSettings.HttpMinimumLogLevel);
+        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = loggingSettings.HttpMinimumLogLevel;
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -1,4 +1,5 @@
-using System.Threading.Channels;
+using System.Globalization;
+using System.Threading.Channels;
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -45,7 +46,8 @@ public class UpdatePlayoutSettingsHandler : IRequestHandler<UpdatePlayoutSetting
         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))
+        foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number, CultureInfo.InvariantCulture))
+                     .Map(p => p.Id))
         {
             await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
         }

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

@@ -0,0 +1,49 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateXmltvSettingsHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    : IRequestHandler<UpdateXmltvSettings, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateXmltvSettings request,
+        CancellationToken cancellationToken)
+    {
+        int playoutDaysToBuild =
+            await configElementRepository
+                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
+                .IfNoneAsync(2);
+
+        if (playoutDaysToBuild < request.XmltvSettings.DaysToBuild)
+        {
+            return BaseError.New(
+                $"XMLTV days to build ({request.XmltvSettings.DaysToBuild}) cannot be greater than Playout days to build ({playoutDaysToBuild})");
+        }
+
+        return await ApplyUpdate(request.XmltvSettings);
+    }
+
+    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings)
+    {
+        await configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild);
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
+
+        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync())
+        {
+            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber));
+        }
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/LoggingSettingsViewModel.cs

@@ -0,0 +1,12 @@
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class LoggingSettingsViewModel
+{
+    public LogEventLevel DefaultMinimumLogLevel { get; set; }
+    public LogEventLevel ScanningMinimumLogLevel { get; set; }
+    public LogEventLevel SchedulingMinimumLogLevel { get; set; }
+    public LogEventLevel StreamingMinimumLogLevel { get; set; }
+    public LogEventLevel HttpMinimumLogLevel { get; set; }
+}

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

@@ -13,5 +13,5 @@ public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKe
     public Task<Option<ConfigElementViewModel>> Handle(
         GetConfigElementByKey request,
         CancellationToken cancellationToken) =>
-        _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
+        _configElementRepository.GetConfigElement(request.Key).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -1,24 +0,0 @@
-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/GetLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetLoggingSettingsHandler.cs

@@ -0,0 +1,40 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetLoggingSettingsHandler : IRequestHandler<GetLoggingSettings, LoggingSettingsViewModel>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetLoggingSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<LoggingSettingsViewModel> Handle(GetLoggingSettings request, CancellationToken cancellationToken)
+    {
+        Option<LogEventLevel> maybeDefaultLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
+
+        Option<LogEventLevel> maybeScanningLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScanning);
+
+        Option<LogEventLevel> maybeSchedulingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScheduling);
+
+        Option<LogEventLevel> maybeStreamingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelStreaming);
+
+        Option<LogEventLevel> maybeHttpLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelHttp);
+
+        return new LoggingSettingsViewModel
+        {
+            DefaultMinimumLogLevel = await maybeDefaultLevel.IfNoneAsync(LogEventLevel.Information),
+            ScanningMinimumLogLevel = await maybeScanningLevel.IfNoneAsync(LogEventLevel.Information),
+            SchedulingMinimumLogLevel = await maybeSchedulingLevel.IfNoneAsync(LogEventLevel.Information),
+            StreamingMinimumLogLevel = await maybeStreamingLevel.IfNoneAsync(LogEventLevel.Information),
+            HttpMinimumLogLevel = await maybeHttpLevel.IfNoneAsync(LogEventLevel.Information)
+        };
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetXmltvSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetXmltvSettings, XmltvSettingsViewModel>
+{
+    public async Task<XmltvSettingsViewModel> Handle(GetXmltvSettings request, CancellationToken cancellationToken)
+    {
+        Option<int> daysToBuild = await configElementRepository.GetValue<int>(ConfigElementKey.XmltvDaysToBuild);
+
+        Option<XmltvTimeZone> maybeTimeZone =
+            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone);
+
+        return new XmltvSettingsViewModel
+        {
+            DaysToBuild = await daysToBuild.IfNoneAsync(2),
+            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local)
+        };
+    }
+}

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public class XmltvSettingsViewModel
+{
+    public int DaysToBuild { get; set; }
+    public XmltvTimeZone TimeZone { get; set; }
+}

ErsatzTV.Application/Configuration/XmltvTimeZone.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public enum XmltvTimeZone
+{
+    Local = 0,
+    Utc = 1
+}

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

@@ -0,0 +1,83 @@
+using System.Globalization;
+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 CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyCollections>,
+    IRequestHandler<SynchronizeEmbyCollections, Either<BaseError, Unit>>
+{
+    public CallEmbyCollectionScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo) : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    public async Task<Either<BaseError, Unit>>
+        Handle(SynchronizeEmbyCollections 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, Unit>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, Unit>>(error.Join());
+            });
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(TvContext dbContext, SynchronizeEmbyCollections request)
+    {
+        DateTime minDateTime = await dbContext.EmbyMediaSources
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId)
+            .Match(l => l.LastCollectionsScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+
+        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        SynchronizeEmbyCollections request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now;
+    }
+
+    private async Task<Either<BaseError, Unit>> PerformScan(
+        string scanner,
+        SynchronizeEmbyCollections request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-emby-collections", request.EmbyMediaSourceId.ToString(CultureInfo.InvariantCulture)
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken).MapT(_ => Unit.Default);
+    }
+}

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -1,4 +1,5 @@
-using System.Threading.Channels;
+using System.Globalization;
+using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
@@ -28,7 +29,8 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         ForceSynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken) => Handle(request, cancellationToken);
 
-    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>.
+        Handle(
             SynchronizeEmbyLibraryByIdIfNeeded request,
             CancellationToken cancellationToken) => Handle(request, cancellationToken);
 
@@ -57,7 +59,7 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
     {
         var arguments = new List<string>
         {
-            "scan-emby", request.EmbyLibraryId.ToString()
+            "scan-emby", request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture)
         };
 
         if (request.ForceScan)
@@ -77,9 +79,11 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         TvContext dbContext,
         ISynchronizeEmbyLibraryById request)
     {
-        return await dbContext.EmbyLibraries
+        DateTime minDateTime = await dbContext.EmbyLibraries
             .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId)
             .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+
+        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
     }
 
     protected override bool ScanIsRequired(
@@ -93,6 +97,6 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         }
 
         DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
-        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+        return request.ForceScan || libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now;
     }
 }

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -52,5 +52,5 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
         return Unit.Default;
     }
 
-    private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+    private sealed record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
 }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyCollections(int EmbyMediaSourceId, bool ForceScan) : IRequest<Either<BaseError, Unit>>,
+    IScannerBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

@@ -3,4 +3,4 @@
 namespace ErsatzTV.Application.Emby;
 
 public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IEmbyBackgroundServiceRequest;
+    IScannerBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -92,7 +92,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
                 toAdd,
                 toRemove,
                 toUpdate);
-            if (ids.Any())
+            if (ids.Count != 0)
             {
                 await _searchIndex.RemoveItems(ids);
                 _searchIndex.Commit();
@@ -102,9 +102,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
         return Unit.Default;
     }
 
-    private record ConnectionParameters(
-        EmbyMediaSource EmbyMediaSource,
-        EmbyConnection ActiveConnection)
+    private sealed record ConnectionParameters(EmbyMediaSource EmbyMediaSource, EmbyConnection ActiveConnection)
     {
         public string ApiKey { get; set; }
     }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

@@ -2,7 +2,7 @@
 
 namespace ErsatzTV.Application.Emby;
 
-public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>, IEmbyBackgroundServiceRequest
+public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>, IScannerBackgroundServiceRequest
 {
     int EmbyLibraryId { get; }
     bool ForceScan { get; }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -8,15 +8,15 @@ namespace ErsatzTV.Application.Emby;
 public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
     Either<BaseError, List<EmbyMediaSource>>>
 {
-    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ChannelWriter<IScannerBackgroundServiceRequest> _scannerWorkerChannel;
 
     public SynchronizeEmbyMediaSourcesHandler(
         IMediaSourceRepository mediaSourceRepository,
-        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        ChannelWriter<IScannerBackgroundServiceRequest> scannerWorkerChannel)
     {
         _mediaSourceRepository = mediaSourceRepository;
-        _channel = channel;
+        _scannerWorkerChannel = scannerWorkerChannel;
     }
 
     public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
@@ -26,8 +26,7 @@ public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmb
         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);
+            await _scannerWorkerChannel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
         }
 
         return mediaSources;

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

@@ -2,7 +2,6 @@
 
 namespace ErsatzTV.Application.Emby;
 
-public record UpdateEmbyLibraryPreferences
-    (List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
+public record UpdateEmbyLibraryPreferences(List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
 
 public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -43,7 +43,6 @@ public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathR
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
         UpdateEmbyPathReplacements request) =>
         _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-            .Map(
-                v => v.ToValidation<BaseError>(
+            .Map(v => v.ToValidation<BaseError>(
                 $"Emby media source {request.EmbyMediaSourceId} does not exist."));
 }

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

@@ -9,4 +9,4 @@ public record EmbyLibraryViewModel(
     LibraryMediaKind MediaKind,
     bool ShouldSyncItems,
     int MediaSourceId)
-    : LibraryViewModel("Emby", Id, Name, MediaKind, MediaSourceId);
+    : LibraryViewModel("Emby", Id, Name, MediaKind, MediaSourceId, string.Empty);

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -10,8 +10,8 @@ namespace ErsatzTV.Application.Emby;
 public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
     Either<BaseError, EmbyConnectionParametersViewModel>>
 {
-    private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly IEmbySecretStore _embySecretStore;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly IMemoryCache _memoryCache;
 
     public GetEmbyConnectionParametersHandler(
@@ -54,8 +54,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
 
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
         _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
-            .Map(
-                v => v.ToValidation<BaseError>(
+            .Map(v => v.ToValidation<BaseError>(
                 "Emby media source does not exist."));
 
     private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
@@ -76,7 +75,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
             .ToValidation<BaseError>("Emby media source requires an api key");
     }
 
-    private record ConnectionParameters(
+    private sealed record ConnectionParameters(
         EmbyMediaSource EmbyMediaSource,
         EmbyConnection ActiveConnection)
     {

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -1,4 +1,3 @@
 namespace ErsatzTV.Application.Emby;
 
-public record GetEmbyPathReplacementsBySourceId
-    (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
+public record GetEmbyPathReplacementsBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,24 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
+        <AnalysisLevel>latest-Recommended</AnalysisLevel>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Bugsnag" Version="3.1.0" />
-      <PackageReference Include="CliWrap" Version="3.6.0" />
+        <PackageReference Include="Bugsnag" Version="4.0.0" />
+        <PackageReference Include="CliWrap" Version="3.9.0" />
         <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-      <PackageReference Include="MediatR" Version="12.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.5.22">
+        <PackageReference Include="MediatR" Version="[12.5.0]" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.7" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.7" />
+        <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
-      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="2.0.0" />
-      <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+        <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
+        <PackageReference Include="WebMarkupMin.Core" Version="2.19.0" />
+        <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -1,5 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artists_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artworks_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Ccommands/@EntryIndexedValue">True</s:Boolean>
@@ -33,7 +34,10 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=plex_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=resolutions_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=resolutions_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=scheduling_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=scheduling_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Ccommands/@EntryIndexedValue">True</s:Boolean>
@@ -41,5 +45,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=subtitles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=templates_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=troubleshooting_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=validators/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

@@ -2,5 +2,4 @@
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public record CopyFFmpegProfile
-    (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+public record CopyFFmpegProfile(int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs

@@ -1,5 +1,7 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
@@ -8,9 +10,13 @@ public class
     CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
 {
     private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
+    private readonly ISearchTargets _searchTargets;
 
-    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
+    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository, ISearchTargets searchTargets)
+    {
         _ffmpegProfileRepository = ffmpegProfileRepository;
+        _searchTargets = searchTargets;
+    }
 
     public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
         CopyFFmpegProfile request,
@@ -19,14 +25,17 @@ public class
             .MapT(PerformCopy)
             .Bind(v => v.ToEitherAsync());
 
-    private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
-        _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
-            .Map(ProjectToViewModel);
+    private async Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request)
+    {
+        FFmpegProfile copy = await _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name);
+        _searchTargets.SearchTargetsChanged();
+        return ProjectToViewModel(copy);
+    }
 
-    private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
+    private static Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
         ValidateName(request).AsTask().MapT(_ => request);
 
-    private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
+    private static Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
         request.NotEmpty(x => x.Name)
             .Bind(_ => request.NotLongerThan(50)(x => x.Name));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -8,18 +8,24 @@ public record CreateFFmpegProfile(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -10,9 +11,13 @@ public class CreateFFmpegProfileHandler :
     IRequestHandler<CreateFFmpegProfile, Either<BaseError, CreateFFmpegProfileResult>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, CreateFFmpegProfileResult>> Handle(
         CreateFFmpegProfile request,
@@ -23,21 +28,21 @@ public class CreateFFmpegProfileHandler :
         return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
-    private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
+    private async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
         TvContext dbContext,
         FFmpegProfile ffmpegProfile)
     {
         await dbContext.FFmpegProfiles.AddAsync(ffmpegProfile);
         await dbContext.SaveChangesAsync();
+        _searchTargets.SearchTargetsChanged();
         return new CreateFFmpegProfileResult(ffmpegProfile.Id);
     }
 
-    private async Task<Validation<BaseError, FFmpegProfile>> Validate(
+    private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
         TvContext dbContext,
         CreateFFmpegProfile request) =>
         (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
-        .Apply(
-            (name, threadCount, resolutionId) => new FFmpegProfile
+        .Apply((name, threadCount, resolutionId) => new FFmpegProfile
         {
             Name = name,
             ThreadCount = threadCount,
@@ -46,14 +51,19 @@ public class CreateFFmpegProfileHandler :
             VaapiDevice = request.VaapiDevice,
             QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
             ResolutionId = resolutionId,
+            ScalingBehavior = request.ScalingBehavior,
             VideoFormat = request.VideoFormat,
+            VideoProfile = request.VideoProfile,
+            VideoPreset = request.VideoPreset,
+            AllowBFrames = request.AllowBFrames,
             BitDepth = request.BitDepth,
             VideoBitrate = request.VideoBitrate,
             VideoBufferSize = request.VideoBufferSize,
+            TonemapAlgorithm = request.TonemapAlgorithm,
             AudioFormat = request.AudioFormat,
             AudioBitrate = request.AudioBitrate,
             AudioBufferSize = request.AudioBufferSize,
-                NormalizeLoudness = request.NormalizeLoudness,
+            NormalizeLoudnessMode = request.NormalizeLoudnessMode,
             AudioChannels = request.AudioChannels,
             AudioSampleRate = request.AudioSampleRate,
             NormalizeFramerate = request.NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -9,23 +10,28 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, Unit>> Handle(
         DeleteFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request);
-        return await LanguageExtensions.Apply(validation, p => DoDeletion(dbContext, p));
+        return await validation.Apply(p => DoDeletion(dbContext, p));
     }
 
-    private static async Task<Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
+    private async Task<Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
     {
         dbContext.FFmpegProfiles.Remove(ffmpegProfile);
         await dbContext.SaveChangesAsync();
+        _searchTargets.SearchTargetsChanged();
         return Unit.Default;
     }
 

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -9,18 +9,24 @@ public record UpdateFFmpegProfile(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -10,9 +11,13 @@ public class
     UpdateFFmpegProfileHandler : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, UpdateFFmpegProfileResult>> Handle(
         UpdateFFmpegProfile request,
@@ -31,11 +36,16 @@ public class
         p.Name = update.Name;
         p.ThreadCount = update.ThreadCount;
         p.HardwareAcceleration = update.HardwareAcceleration;
+        p.VaapiDisplay = update.VaapiDisplay;
         p.VaapiDriver = update.VaapiDriver;
         p.VaapiDevice = update.VaapiDevice;
         p.QsvExtraHardwareFrames = update.QsvExtraHardwareFrames;
         p.ResolutionId = update.ResolutionId;
+        p.ScalingBehavior = update.ScalingBehavior;
         p.VideoFormat = update.VideoFormat;
+        p.VideoProfile = update.VideoProfile;
+        p.VideoPreset = update.VideoPreset;
+        p.AllowBFrames = update.AllowBFrames;
 
         // mpeg2video only supports 8-bit content
         p.BitDepth = update.VideoFormat == FFmpegProfileVideoFormat.Mpeg2Video
@@ -44,15 +54,19 @@ public class
 
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
+        p.TonemapAlgorithm = update.TonemapAlgorithm;
         p.AudioFormat = update.AudioFormat;
         p.AudioBitrate = update.AudioBitrate;
         p.AudioBufferSize = update.AudioBufferSize;
-        p.NormalizeLoudness = update.NormalizeLoudness;
+        p.NormalizeLoudnessMode = update.NormalizeLoudnessMode;
         p.AudioChannels = update.AudioChannels;
         p.AudioSampleRate = update.AudioSampleRate;
         p.NormalizeFramerate = update.NormalizeFramerate;
         p.DeinterlaceVideo = update.DeinterlaceVideo;
         await dbContext.SaveChangesAsync();
+
+        _searchTargets.SearchTargetsChanged();
+
         return new UpdateFFmpegProfileResult(p.Id);
     }
 

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,4 +1,7 @@
 using System.Diagnostics;
+using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -10,13 +13,16 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly ILocalFileSystem _localFileSystem;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public UpdateFFmpegSettingsHandler(
         IConfigElementRepository configElementRepository,
-        ILocalFileSystem localFileSystem)
+        ILocalFileSystem localFileSystem,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
     {
         _configElementRepository = configElementRepository;
         _localFileSystem = localFileSystem;
+        _workerChannel = workerChannel;
     }
 
     public Task<Either<BaseError, Unit>> Handle(
@@ -52,10 +58,8 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             UseShellExecute = false
         };
 
-        using var test = new Process
-        {
-            StartInfo = startInfo
-        };
+        using var test = new Process();
+        test.StartInfo = startInfo;
 
         test.Start();
         string output = await test.StandardOutput.ReadToEndAsync();
@@ -71,10 +75,13 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
         await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegDefaultProfileId,
-            request.Settings.DefaultFFmpegProfileId.ToString());
+            request.Settings.DefaultFFmpegProfileId.ToString(CultureInfo.InvariantCulture));
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegSaveReports,
             request.Settings.SaveReports.ToString());
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegHlsDirectOutputFormat,
+            request.Settings.HlsDirectOutputFormat);
 
         if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
         {
@@ -85,6 +92,26 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             ConfigElementKey.FFmpegPreferredLanguageCode,
             request.Settings.PreferredAudioLanguageCode);
 
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegUseEmbeddedSubtitles,
+            request.Settings.UseEmbeddedSubtitles);
+
+        // do not extract when subtitles are not used
+        if (request.Settings.UseEmbeddedSubtitles == false)
+        {
+            request.Settings.ExtractEmbeddedSubtitles = false;
+        }
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegExtractEmbeddedSubtitles,
+            request.Settings.ExtractEmbeddedSubtitles);
+
+        // queue extracting all embedded subtitles
+        if (request.Settings.ExtractEmbeddedSubtitles)
+        {
+            await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(Option<int>.None));
+        }
+
         if (request.Settings.GlobalWatermarkId is not null)
         {
             await _configElementRepository.Upsert(

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -9,18 +9,24 @@ public record FFmpegProfileViewModel(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     ResolutionViewModel Resolution,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Application.FFmpegProfiles;
+using ErsatzTV.FFmpeg.OutputFormat;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
 
 public class FFmpegSettingsViewModel
 {
@@ -6,10 +8,13 @@ public class FFmpegSettingsViewModel
     public string FFprobePath { get; set; }
     public int DefaultFFmpegProfileId { get; set; }
     public string PreferredAudioLanguageCode { get; set; }
+    public bool UseEmbeddedSubtitles { get; set; }
+    public bool ExtractEmbeddedSubtitles { get; set; }
     public bool SaveReports { get; set; }
     public int? GlobalWatermarkId { get; set; }
     public int? GlobalFallbackFillerId { get; set; }
     public int HlsSegmenterIdleTimeout { get; set; }
     public int WorkAheadSegmenterLimit { get; set; }
     public int InitialSegmentCount { get; set; }
+    public OutputFormatKind HlsDirectOutputFormat { get; set; }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Resolutions;
-using ErsatzTV.Core.Api.FFmpegProfiles;
+using ErsatzTV.Core.Api.FFmpegProfiles;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
@@ -12,18 +11,24 @@ internal static class Mapper
             profile.Name,
             profile.ThreadCount,
             profile.HardwareAcceleration,
+            profile.VaapiDisplay ?? "drm",
             profile.VaapiDriver,
             profile.VaapiDevice,
             profile.QsvExtraHardwareFrames,
-            Project(profile.Resolution),
+            Resolutions.Mapper.ProjectToViewModel(profile.Resolution),
+            profile.ScalingBehavior,
             profile.VideoFormat,
+            profile.VideoProfile,
+            profile.VideoPreset ?? string.Empty,
+            profile.AllowBFrames,
             profile.BitDepth,
             profile.VideoBitrate,
             profile.VideoBufferSize,
+            profile.TonemapAlgorithm,
             profile.AudioFormat,
             profile.AudioBitrate,
             profile.AudioBufferSize,
-            profile.NormalizeLoudness,
+            profile.NormalizeLoudnessMode,
             profile.AudioChannels,
             profile.AudioSampleRate,
             profile.NormalizeFramerate,
@@ -43,21 +48,20 @@ internal static class Mapper
             ffmpegProfile.Name,
             ffmpegProfile.ThreadCount,
             (int)ffmpegProfile.HardwareAcceleration,
+            ffmpegProfile.VaapiDisplay,
             (int)ffmpegProfile.VaapiDriver,
             ffmpegProfile.VaapiDevice,
             ffmpegProfile.ResolutionId,
             (int)ffmpegProfile.VideoFormat,
             ffmpegProfile.VideoBitrate,
             ffmpegProfile.VideoBufferSize,
+            (int)ffmpegProfile.TonemapAlgorithm,
             (int)ffmpegProfile.AudioFormat,
             ffmpegProfile.AudioBitrate,
             ffmpegProfile.AudioBufferSize,
-            ffmpegProfile.NormalizeLoudness,
+            (int)ffmpegProfile.NormalizeLoudnessMode,
             ffmpegProfile.AudioChannels,
             ffmpegProfile.AudioSampleRate,
             ffmpegProfile.NormalizeFramerate,
             ffmpegProfile.DeinterlaceVideo);
-
-    private static ResolutionViewModel Project(Resolution resolution) =>
-        new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
 }