add small hdr test file

.config/dotnet-tools.json

@@ -3,11 +3,10 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2025.3.0.2",
+      "version": "2024.1.1",
       "commands": [
         "jb"
-      ],
-      "rollForward": false
+      ]
     }
   }
-}
+}

.editorconfig

@@ -1,8 +1,9 @@
+
 [*]
 charset=utf-8
 end_of_line=lf
 trim_trailing_whitespace=true
-insert_final_newline=true
+insert_final_newline=false
 indent_style=space
 indent_size=4
 
@@ -14,7 +15,7 @@ csharp_style_expression_bodied_constructors=true:none
 csharp_style_expression_bodied_methods=true:none
 csharp_style_expression_bodied_properties=true:suggestion
 csharp_style_var_elsewhere=false:suggestion
-csharp_style_var_for_built_in_types=false:none
+csharp_style_var_for_built_in_types=false:suggestion
 csharp_style_var_when_type_is_apparent=true:suggestion
 dotnet_naming_rule.local_constants_rule.severity=warning
 dotnet_naming_rule.local_constants_rule.style=all_upper_style
@@ -41,8 +42,6 @@ resharper_braces_for_for=required
 resharper_braces_for_foreach=required
 resharper_braces_for_ifelse=required
 resharper_braces_for_while=required
-resharper_csharp_arguments_literal=positional
-resharper_csharp_arguments_named=positional
 resharper_csharp_insert_final_newline=true
 resharper_csharp_max_attribute_length_for_same_line=0
 resharper_csharp_place_accessorholder_attribute_on_same_line=never
@@ -67,7 +66,7 @@ resharper_built_in_type_reference_style_highlighting=hint
 resharper_redundant_base_qualifier_highlighting=warning
 resharper_suggest_var_or_type_built_in_types_highlighting=hint
 resharper_suggest_var_or_type_elsewhere_highlighting=hint
-resharper_suggest_var_or_type_simple_types_highlighting=none
+resharper_suggest_var_or_type_simple_types_highlighting=hint
 resharper_web_config_module_not_resolved_highlighting=warning
 resharper_web_config_type_not_resolved_highlighting=warning
 resharper_web_config_wrong_module_highlighting=warning
@@ -85,22 +84,7 @@ tab_width=4
 indent_style = space
 indent_size = 2
 
-[*.json]
-ij_json_array_wrapping = normal
-ij_json_keep_blank_lines_in_code = 0
-ij_json_keep_indents_on_empty_lines = false
-ij_json_keep_line_breaks = true
-ij_json_keep_trailing_comma = false
-ij_json_object_wrapping = normal
-ij_json_property_alignment = do_not_align
-ij_json_space_after_colon = true
-ij_json_space_after_comma = true
-ij_json_space_before_colon = false
-ij_json_space_before_comma = false
-ij_json_spaces_within_braces = true
-ij_json_spaces_within_brackets = true
-ij_json_wrap_long_lines = false
 
 [*.cs]
 # disable CA1848: Use the LoggerMessage delegates`
-dotnet_diagnostic.ca1848.severity = none
+dotnet_diagnostic.ca1848.severity = none

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Feature Requests
-    url: https://features.ersatztv.org
-    about: Features
-  - name: Contact
-    url: https://ersatztv.org/contact
-    about: Chat Options
-  - name: Community
-    url: https://discuss.ersatztv.org
-    about: Forum
-  - name: Discussions
-    url: https://github.com/ErsatzTV/ErsatzTV/discussions
-    about: Discuss

.github/ISSUE_TEMPLATE/issue.yml

@@ -1,77 +0,0 @@
-name: Issue Report
-description: Report an issue
-type: Bug
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this form! Please make sure to fill all fields, including the Title above.
-  - type: checkboxes
-    id: before-posting
-    attributes:
-      label: "This issue respects the following points:"
-      description: All conditions are **required**. Failure to comply with any of these conditions may cause your issue to be closed without comment.
-      options:
-        - label: This is a **bug**, not a question or a configuration issue; Please visit our [forum](https://discuss.ersatztv.org) or [chat](https://ersatztv.org/contact) first to troubleshoot with volunteers before creating a report.
-          required: true
-        - label: This issue is **not** already reported on [GitHub](https://github.com/ErsatzTV/ErsatzTV/issues?q=is%3Aopen+is%3Aissue) _(I've searched it)_.
-          required: true
-        - label: I'm using an up to date version of ErsatzTV (full release or develop release); We generally do not support previous older versions. If possible, please update to the latest version before opening an issue.
-          required: true
-        - label: This report addresses only a single issue; If you encounter multiple issues, please create separate reports for each one.
-          required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: |
-        Description of the problem or issue here.
-    validations:
-      required: true
-  - type: textarea
-    id: repro-steps
-    attributes:
-      label: Steps to reproduce the problem.
-      description: |
-        1. Step 1
-        2. Step 2
-        3. Step 3
-
-        If this is a playback issue, follow these steps and post the resulting zip:
-          1. Search for the required content using the search bar.
-          2. Use the overflow/three dots menu on the content and select Troubleshoot Playback.
-          3. Select the appropriate Playback Settings that trigger the undesired behavior.
-          4. Click Play to start playback.
-          5. Repeat steps 3 and 4 until the undesired behavior is reproduced.
-          6. Click Download Results to have ErsatzTV collect relevant troubleshooting logs (ffmpeg log, ffmpeg profile, hardware capabilities, media info, etc) and compress them in a zip file.
-          7. Attach the zip to this field.
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: What is the current _bug_ behavior?
-      description: Write down the incorrect behavior that currently happens after following the reproduction steps.
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: What is the expected _correct_ behavior?
-      description: Write down the correct expected behavior that is supposed to happen after following the reproduction steps.
-    validations:
-      required: true
-  - type: input
-    id: version
-    attributes:
-      label: Specify full version
-      description: Provide the full version of ErsatzTV, which can be found below the left menu.
-      placeholder: |
-        25.5.0-bd695412-docker-amd64
-    validations:
-      required: true
-  - type: textarea
-    id: additional-information
-    attributes:
-      label: Additional information
-      description: Any additional information that might be useful to this issue.

.github/workflows/artifacts.yml

@@ -25,26 +25,18 @@ on:
         required: true
       gh_token:
         required: true
-      azure_client_id:
-        required: true
-      azure_tenant_id:
-        required: true
-      azure_subscription_id:
-        required: true
-permissions:
-  id-token: write
-  contents: write
 jobs:
   build_and_upload_mac:
     name: Mac Build & Upload
     runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - os: macos-14
+          - os: macos-13
             kind: macOS
             target: osx-x64
-          - os: macos-14
+          - os: macos-13
             kind: macOS
             target: osx-arm64
     steps:
@@ -54,10 +46,8 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -81,8 +71,8 @@ jobs:
         shell: bash
         run: |
           sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.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 net10.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.Scanner/ErsatzTV.Scanner.csproj --framework net8.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 net8.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
 
       - name: Bundle
         shell: bash
@@ -134,20 +124,22 @@ jobs:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
           fail-if-no-assets: false
-          assets: "*${{ matrix.target }}.dmg"
+          assets: |
+            *${{ matrix.target }}.dmg
 
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
           prerelease: false
           tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.dmg"
+          files: |
+            ${{ env.RELEASE_NAME }}.dmg
         env:
           GITHUB_TOKEN: ${{ secrets.gh_token }}
-
-  build_and_upload_linux:
-    name: Build & Upload Linux
+  build_and_upload:
+    name: Build & Upload
     runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
@@ -160,19 +152,20 @@ jobs:
           - os: ubuntu-latest
             kind: linux
             target: linux-arm
-          - os: ubuntu-24.04-arm
+          - os: ubuntu-latest
             kind: linux
             target: linux-arm64
+          - os: windows-latest
+            kind: windows
+            target: win-x64
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -180,6 +173,14 @@ jobs:
       - name: Install dependencies
         run: dotnet restore -r "${{ matrix.target }}"
 
+      - uses: suisei-cn/actions-download-file@v1.3.0
+        if: ${{ matrix.kind == 'windows' }}
+        id: downloadffmpeg
+        name: Download ffmpeg
+        with:
+          url: "https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-06-12-14-05/ffmpeg-n7.1.1-22-g0f1fe3d153-win64-gpl-7.1.zip"
+          target: ffmpeg/
+
       - name: Build
         shell: bash
         run: |
@@ -189,12 +190,31 @@ jobs:
 
           # Build everything
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.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 net10.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
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -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 net8.0 --runtime "${{ matrix.target }}" -c Release -o "main" -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/"
-          tar czvf "${release_name}.tar.gz" "$release_name"
+
+          # Build Windows launcher
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
+            ls -l ErsatzTV-Windows/target/release
+            mv ErsatzTV-Windows/target/release/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
+          fi
+
+          # Download ffmpeg
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
+            rm -f "$release_name/ffplay.exe"
+          fi
+
+          # Pack files
+          if [ "${{ matrix.kind }}" == "windows" ]; then
+            7z a -tzip "${release_name}.zip" "./${release_name}/*"
+          else
+            tar czvf "${release_name}.tar.gz" "$release_name"
+          fi
 
           # Delete output directory
           rm -r "$release_name"
@@ -206,131 +226,17 @@ jobs:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
           fail-if-no-assets: false
-          assets: "*${{ matrix.target }}.tar.gz"
+          assets: |
+            *${{ matrix.target }}.zip
+            *${{ matrix.target }}.tar.gz
 
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
           prerelease: false
           tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.tar.gz"
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}
-
-  build_dotnet_windows:
-    name: Build dotnet for Windows
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "win-x64"
-
-      - name: Build dotnet projects
-        shell: bash
-        run: |
-          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Upload .NET Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: |
-            scanner/
-            main/
-          retention-days: 1
-
-  package_and_upload_windows:
-    name: Package & Upload Windows
-    runs-on: windows-latest
-    needs: build_dotnet_windows
-    steps:
-      - name: Download dotnet artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: dotnet-build
-
-      - name: Azure login
-        uses: azure/login@v2
-        with:
-          client-id: ${{ secrets.azure_client_id }}
-          tenant-id: ${{ secrets.azure_tenant_id }}
-          subscription-id: ${{ secrets.azure_subscription_id }}
-          enable-AzPSSession: true
-
-      - name: Sign dotnet artifacts
-        uses: azure/trusted-signing-action@v0
-        with:
-          endpoint: https://eus.codesigning.azure.net/
-          trusted-signing-account-name: ArtifactSigning
-          certificate-profile-name: ErsatzTV
-          files-folder: ${{ github.workspace }}/dotnet-build
-          files-folder-recurse: true
-          files-folder-filter: ErsatzTV.exe,ErsatzTV.Scanner.exe
-          file-digest: SHA256
-          timestamp-rfc3161: http://timestamp.acs.microsoft.com
-          timestamp-digest: SHA256
-
-      - name: Download rust launcher
-        uses: suisei-cn/actions-download-file@v1.3.0
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-Windows/releases/download/v1.0.0/ErsatzTV-Windows.exe"
-          target: rust-build/
-
-      - name: Download ffmpeg
-        uses: suisei-cn/actions-download-file@v1.3.0
-        id: downloadffmpeg
-        with:
-          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: Package artifacts
-        shell: bash
-        run: |
-          release_name="ErsatzTV-${{ inputs.release_version }}-win-x64"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-          mkdir "$release_name"
-
-          mv dotnet-build/scanner/* "$release_name/"
-          mv dotnet-build/main/* "$release_name/"
-
-          # dotnet shouldn't copy the resources here, but it does
-          rm -rf "$release_name/Resources"
-
-          mv rust-build/ErsatzTV-Windows.exe "$release_name/ErsatzTV-Windows.exe"
-          7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
-          rm -f "$release_name/ffplay.exe"
-
-          (cd "${release_name}" && 7z a "../${release_name}.zip" .)
-
-      - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
-        if: ${{ inputs.release_tag == 'develop' }}
-        with:
-          token: ${{ secrets.gh_token }}
-          tag: ${{ inputs.release_tag }}
-          fail-if-no-assets: false
-          assets: "*win-x64.zip"
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.zip"
+          files: |
+            ${{ env.RELEASE_NAME }}.zip
+            ${{ env.RELEASE_NAME }}.tar.gz
         env:
           GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -46,11 +46,7 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
-      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
-      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
-      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-  build_images:
+  build_and_push:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:

.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,28 +20,33 @@ on:
       docker_hub_access_token:
         required: true
 jobs:
-  build_images:
-    name: Build ${{ matrix.name }} image
-    runs-on: ${{ matrix.os }}
+  build_and_push:
+    name: Build & Publish
+    runs-on: ubuntu-latest
     if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - name: amd64
-            os: ubuntu-latest
+          - name: base
             path: ''
-            suffix: '-amd64'
-            platform: 'linux/amd64'
+            suffix: ''
+            qemu: false
+          - name: nvidia
+            path: 'nvidia/'
+            suffix: '-nvidia'
+            qemu: false
+          - name: vaapi
+            path: 'vaapi/'
+            suffix: '-vaapi'
+            qemu: false
           - name: arm32v7
-            os: ubuntu-latest
             path: 'arm32v7/'
             suffix: '-arm'
-            platform: 'linux/arm/v7'
+            qemu: true
           - name: arm64
-            os: ubuntu-24.04-arm
             path: 'arm64/'
             suffix: '-arm64'
-            platform: 'linux/arm64'
+            qemu: true
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -49,11 +54,12 @@ jobs:
           fetch-depth: 0
 
       - name: Set up QEMU
-        if: ${{ matrix.name == 'arm32v7' }}
         uses: docker/setup-qemu-action@v3
+        if: ${{ matrix.qemu == true }}
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        id: docker-buildx
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
@@ -68,74 +74,52 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push by digest
-        id: build
+      - name: Build and push
         uses: docker/build-push-action@v5
         with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
           file: ./docker/${{ matrix.path }}Dockerfile
           push: true
-          provenance: false
-          platforms: ${{ matrix.platform }}
           build-args: |
             INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          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
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
 
-      - name: Save digest to artifact
-        run: echo ${{ steps.build.outputs.digest }} > digest.txt
-
-      - name: Upload digest artifact
-        uses: actions/upload-artifact@v4
+      - name: Build and push
+        uses: docker/build-push-action@v5
         with:
-          name: digest-${{ matrix.name }}
-          path: digest.txt
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          platforms: 'linux/arm64'
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm64' }}
 
-  merge_manifests:
-    name: Merge Manifests
-    runs-on: ubuntu-latest
-    needs: build_images
-    steps:
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
+      - name: Build and push
+        uses: docker/build-push-action@v5
         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 }}
+          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 }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm32v7' }}

.github/workflows/pr.yml

@@ -2,41 +2,14 @@
 on:
   pull_request:
 jobs:
-  build_and_analyze:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Prep project file
-        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore /p:EnableThreadingAnalyzers=true
   build_and_test_windows:
     runs-on: windows-latest
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -52,44 +25,36 @@ jobs:
 
       - name: Test
         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: ${{ 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
+    runs-on: ubuntu-latest
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 
       - name: Install dependencies
-        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
+        run: dotnet restore
 
       - name: Prep project file
         run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
 
       - name: Build
-        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
+        run: dotnet build --configuration Release --no-restore
 
       - name: Test
         run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
   build_and_test_mac:
-    runs-on: macos-14
+    runs-on: macos-13
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
@@ -97,10 +62,8 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear

.github/workflows/release.yml

@@ -41,10 +41,7 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
-      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
-      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
-      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-  build_images:
+  build_and_push:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:

.gitignore

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

Directory.Build.props

@@ -2,6 +2,5 @@
     <PropertyGroup>
         <InformationalVersion>develop</InformationalVersion>
         <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
-        <AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>
     </PropertyGroup>
-</Project>
+</Project>

Directory.Build.targets

@@ -1,15 +0,0 @@
-<Project>
-    <PropertyGroup>
-        <EnableThreadingAnalyzers Condition="'$(EnableThreadingAnalyzers)' == ''">false</EnableThreadingAnalyzers>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <PackageReference
-            Include="Microsoft.VisualStudio.Threading.Analyzers"
-            Version="17.14.15"
-            Condition="'$(EnableThreadingAnalyzers)' == 'true'">
-            <PrivateAssets>all</PrivateAssets>
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-    </ItemGroup>
-</Project>

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

ErsatzTV.Application/Artworks/ArtworkContentTypeModel.cs

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

@@ -6,25 +6,24 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Artworks;
 
-public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetArtwork, Either<BaseError, Artwork>>
+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,
+        GetArtwork request, 
         CancellationToken cancellationToken)
     {
-        try
-        {
+        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, cancellationToken)
+                .SelectOneAsync(a => a.Id, a => a.Id == request.Id)
                 .MapT(Project);
-
+            
             return artwork.ToEither(BaseError.New("Artwork not found"));
+        
         }
         catch (Exception ex)
         {
@@ -32,11 +31,12 @@ public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
         }
     }
 
-    private static Artwork Project(Artwork artwork) =>
-        new()
-        {
+    private static Artwork Project(Artwork artwork)
+    {
+        return new Artwork {
             Id = artwork.Id,
             Path = artwork.Path,
             ArtworkKind = artwork.ArtworkKind
         };
+    }
 }

ErsatzTV.Application/Channels/ChannelSortViewModel.cs

@@ -1,10 +0,0 @@
-namespace ErsatzTV.Application.Channels;
-
-public class ChannelSortViewModel
-{
-    public int Id { get; set; }
-    public string Number { get; set; }
-    public string Name { get; set; }
-    public string OriginalNumber { get; set; }
-    public bool HasChanged => OriginalNumber != Number;
-}

ErsatzTV.Application/Channels/ChannelStreamingSpecsViewModel.cs

@@ -1,11 +0,0 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.Channels;
-
-public record ChannelStreamingSpecsViewModel(
-    int Height,
-    int Width,
-    int Bitrate,
-    FFmpegProfileVideoFormat VideoFormat,
-    string VideoProfile,
-    FFmpegProfileAudioFormat AudioFormat);

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,6 +1,5 @@
-using System.Net;
-using ErsatzTV.Application.Artworks;
 using ErsatzTV.Core.Domain;
+using System.Net;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -11,16 +10,10 @@ public record ChannelViewModel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    double? SlugSeconds,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -29,11 +22,7 @@ public record ChannelViewModel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg)
+    ChannelSongVideoMode SongVideoMode)
 {
     public string WebEncodedName => WebUtility.UrlEncode(Name);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -10,16 +9,10 @@ public record CreateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    double? SlugSeconds,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -27,8 +20,4 @@ public record CreateChannel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg) : IRequest<Either<BaseError, CreateChannelResult>>;
+    ChannelSongVideoMode SongVideoMode) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,5 +1,4 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -23,7 +22,7 @@ public class CreateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
         return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
@@ -36,94 +35,63 @@ public class CreateChannelHandler(
         return new CreateChannelResult(channel.Id);
     }
 
-    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request, CancellationToken cancellationToken) =>
-        (ValidateName(request), await ValidateNumber(dbContext, request, cancellationToken),
-            await FFmpegProfileMustExist(dbContext, request, cancellationToken),
-            await WatermarkMustExist(dbContext, request, cancellationToken),
-            await FillerPresetMustExist(dbContext, request, cancellationToken),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
-        .Apply((
-            name,
-            number,
-            ffmpegProfileId,
-            watermarkId,
-            fillerPresetId,
-            _) =>
-        {
-            var artwork = new List<Artwork>();
-            if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request),
+            await FFmpegProfileMustExist(dbContext, request),
+            await WatermarkMustExist(dbContext, request),
+            await FillerPresetMustExist(dbContext, request))
+        .Apply(
+            (
+                name,
+                number,
+                ffmpegProfileId,
+                watermarkId,
+                fillerPresetId) =>
             {
-                string logo = request.Logo.Path;
-                if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+                var artwork = new List<Artwork>();
+                if (!string.IsNullOrWhiteSpace(request.Logo))
                 {
-                    logo = logo.Replace("iptv/logos/", string.Empty);
+                    artwork.Add(
+                        new Artwork
+                        {
+                            Path = request.Logo,
+                            ArtworkKind = ArtworkKind.Logo,
+                            DateAdded = DateTime.UtcNow,
+                            DateUpdated = DateTime.UtcNow
+                        });
                 }
 
-                artwork.Add(
-                    new Artwork
-                    {
-                        Path = logo,
-                        ArtworkKind = ArtworkKind.Logo,
-                        OriginalContentType = !string.IsNullOrEmpty(request.Logo.ContentType)
-                            ? request.Logo.ContentType
-                            : null,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = DateTime.UtcNow
-                    });
-            }
+                var channel = new Channel(Guid.NewGuid())
+                {
+                    Name = name,
+                    Number = number,
+                    Group = request.Group,
+                    Categories = request.Categories,
+                    FFmpegProfileId = ffmpegProfileId,
+                    ProgressMode = request.ProgressMode,
+                    StreamingMode = request.StreamingMode,
+                    Artwork = artwork,
+                    PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
+                    PreferredAudioTitle = request.PreferredAudioTitle,
+                    PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
+                    SubtitleMode = request.SubtitleMode,
+                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
+                    SongVideoMode = request.SongVideoMode
+                };
 
-            var channel = new Channel(Guid.NewGuid())
-            {
-                Name = name,
-                Number = number,
-                SortNumber = double.Parse(number, CultureInfo.InvariantCulture),
-                Group = request.Group,
-                Categories = request.Categories,
-                FFmpegProfileId = ffmpegProfileId,
-                SlugSeconds = request.SlugSeconds,
-                PlayoutSource = request.PlayoutSource,
-                PlayoutMode = request.PlayoutMode,
-                MirrorSourceChannelId = request.MirrorSourceChannelId,
-                PlayoutOffset = request.PlayoutOffset,
-                StreamingMode = request.StreamingMode,
-                Artwork = artwork,
-                StreamSelectorMode = request.StreamSelectorMode,
-                StreamSelector = request.StreamSelector,
-                PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
-                PreferredAudioTitle = request.PreferredAudioTitle,
-                PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
-                SubtitleMode = request.SubtitleMode,
-                MusicVideoCreditsMode = request.MusicVideoCreditsMode,
-                MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
-                SongVideoMode = request.SongVideoMode,
-                TranscodeMode = request.TranscodeMode,
-                IdleBehavior = request.IdleBehavior,
-                IsEnabled = request.IsEnabled,
-                ShowInEpg = request.IsEnabled && request.ShowInEpg
-            };
+                foreach (int id in watermarkId)
+                {
+                    channel.WatermarkId = id;
+                }
 
-            if (channel.PlayoutSource is ChannelPlayoutSource.Mirror)
-            {
-                channel.PlayoutMode = ChannelPlayoutMode.Continuous;
-            }
-            else
-            {
-                channel.MirrorSourceChannelId = null;
-                channel.PlayoutOffset = null;
-            }
+                foreach (int id in fillerPresetId)
+                {
+                    channel.FallbackFillerId = id;
+                }
 
-            foreach (int id in watermarkId)
-            {
-                channel.WatermarkId = id;
-            }
-
-            foreach (int id in fillerPresetId)
-            {
-                channel.FallbackFillerId = id;
-            }
-
-            return channel;
-        });
+                return channel;
+            });
 
     private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
         createChannel.NotEmpty(c => c.Name)
@@ -131,11 +99,10 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         Option<Channel> maybeExistingChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number, cancellationToken);
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
         return maybeExistingChannel.Match<Validation<BaseError, string>>(
             _ => BaseError.New("Channel number must be unique"),
             () =>
@@ -151,10 +118,9 @@ public class CreateChannelHandler(
 
     private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken) =>
+        CreateChannel createChannel) =>
         dbContext.FFmpegProfiles
-            .CountAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken)
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => createChannel.FFmpegProfileId)
@@ -162,8 +128,7 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         if (createChannel.WatermarkId is null)
         {
@@ -171,7 +136,7 @@ public class CreateChannelHandler(
         }
 
         return await dbContext.ChannelWatermarks
-            .CountAsync(w => w.Id == createChannel.WatermarkId, cancellationToken)
+            .CountAsync(w => w.Id == createChannel.WatermarkId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.WatermarkId))
@@ -180,8 +145,7 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         if (createChannel.FallbackFillerId is null)
         {
@@ -190,53 +154,12 @@ public class CreateChannelHandler(
 
         return await dbContext.FillerPresets
             .Filter(fp => fp.FillerKind == FillerKind.Fallback)
-            .CountAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.FallbackFillerId))
-            .Map(o => o.ToValidation<BaseError>(
-                $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
-    }
-
-    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
-        TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
-    {
-        if (createChannel.PlayoutSource is not ChannelPlayoutSource.Mirror)
-        {
-            return Unit.Default;
-        }
-
-        Option<Channel> maybeMirrorSource = await dbContext.Channels
-            .AsNoTracking()
-            .SelectOneAsync(
-                c => c.Id == createChannel.MirrorSourceChannelId,
-                c => c.Id == createChannel.MirrorSourceChannelId,
-                cancellationToken);
-
-        if (maybeMirrorSource.IsNone)
-        {
-            return BaseError.New("Mirror source channel does not exist.");
-        }
-
-        foreach (var mirrorSource in maybeMirrorSource)
-        {
-            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
-            {
-                return BaseError.New(
-                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
-            }
-        }
-
-        foreach (TimeSpan playoutOffset in Optional(createChannel.PlayoutOffset))
-        {
-            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
-            {
-                return BaseError.New("Playout offset must not be greater than 12 hours");
-            }
-        }
-
-        return Unit.Default;
+            .Map(
+                o => o.ToValidation<BaseError>(
+                    $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
     }
 }

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,6 +1,6 @@
-using System.IO.Abstractions;
 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;
@@ -12,26 +12,26 @@ namespace ErsatzTV.Application.Channels;
 public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
+    private readonly ILocalFileSystem _localFileSystem;
     private readonly ISearchTargets _searchTargets;
     private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public DeleteChannelHandler(
         ChannelWriter<IBackgroundServiceRequest> workerChannel,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
+        ILocalFileSystem localFileSystem,
         ISearchTargets searchTargets)
     {
         _workerChannel = workerChannel;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
+        _localFileSystem = localFileSystem;
         _searchTargets = searchTargets;
     }
 
     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, cancellationToken);
+        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request);
         return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
     }
 
@@ -44,7 +44,7 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
         // delete channel data from channel guide cache
         string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
-        if (_fileSystem.File.Exists(cacheFile))
+        if (_localFileSystem.FileExists(cacheFile))
         {
             File.Delete(cacheFile);
         }
@@ -57,11 +57,10 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
     private static async Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        DeleteChannel deleteChannel,
-        CancellationToken cancellationToken)
+        DeleteChannel deleteChannel)
     {
         Option<Channel> maybeChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId, cancellationToken);
+            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId);
         return maybeChannel.ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.");
     }
 }

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using System.IO.Abstractions;
 using System.Xml;
 using ErsatzTV.Application.Configuration;
 using ErsatzTV.Core;
@@ -12,7 +11,6 @@ using ErsatzTV.Core.Iptv;
 using ErsatzTV.Core.Jellyfin;
 using ErsatzTV.Core.Streaming;
 using ErsatzTV.Infrastructure.Data;
-using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Microsoft.IO;
@@ -27,7 +25,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelDataHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -35,14 +32,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     public RefreshChannelDataHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         IConfigElementRepository configElementRepository,
         ILogger<RefreshChannelDataHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _configElementRepository = configElementRepository;
         _logger = logger;
@@ -50,278 +45,207 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     public async Task Handle(RefreshChannelData request, CancellationToken cancellationToken)
     {
-        try
+        _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
+
+        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
+
+        string movieTemplateFileName = GetMovieTemplateFileName();
+        string episodeTemplateFileName = GetEpisodeTemplateFileName();
+        string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
+        string songTemplateFileName = GetSongTemplateFileName();
+        string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
+        if (movieTemplateFileName is null || episodeTemplateFileName is null || musicVideoTemplateFileName is null ||
+            songTemplateFileName is null || otherVideoTemplateFileName is null)
         {
-            _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
-
-            _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
-
-            string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            int hiddenCount = await dbContext.Channels
-                .Where(c => c.Number == request.ChannelNumber && c.ShowInEpg == false)
-                .CountAsync(cancellationToken);
-            if (hiddenCount > 0)
-            {
-                File.Delete(targetFile);
-                return;
-            }
-
-            string movieTemplateFileName = GetMovieTemplateFileName();
-            string episodeTemplateFileName = GetEpisodeTemplateFileName();
-            string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
-            string songTemplateFileName = GetSongTemplateFileName();
-            string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
-            string remoteStreamTemplateFileName = GetRemoteStreamTemplateFileName();
-            if (movieTemplateFileName is null || episodeTemplateFileName is null ||
-                musicVideoTemplateFileName is null ||
-                songTemplateFileName is null || otherVideoTemplateFileName is null ||
-                remoteStreamTemplateFileName is null)
-            {
-                return;
-            }
-
-            var minifier = new XmlMinifier(
-                new XmlMinificationSettings
-                {
-                    MinifyWhitespace = true,
-                    RemoveXmlComments = true,
-                    CollapseTagsWithoutContent = true
-                });
-
-            var templateContext = new XmlTemplateContext();
-
-            string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
-            var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
-
-            string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
-            var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
-
-            string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
-            var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
-
-            string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
-            var songTemplate = Template.Parse(songText, songTemplateFileName);
-
-            string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
-            var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
-
-            string remoteStreamText = await File.ReadAllTextAsync(remoteStreamTemplateFileName, cancellationToken);
-            var remoteStreamTemplate = Template.Parse(remoteStreamText, remoteStreamTemplateFileName);
-
-            TimeSpan playoutOffset = TimeSpan.Zero;
-            string mirrorChannelNumber = null;
-            Option<Channel> maybeChannel = await dbContext.Channels
-                .AsNoTracking()
-                .Include(c => c.MirrorSourceChannel)
-                .Filter(c => c.PlayoutSource == ChannelPlayoutSource.Mirror && c.MirrorSourceChannelId != null)
-                .SelectOneAsync(
-                    c => c.Number == request.ChannelNumber,
-                    c => c.Number == request.ChannelNumber,
-                    cancellationToken);
-            foreach (Channel channel in maybeChannel)
-            {
-                mirrorChannelNumber = channel.MirrorSourceChannel.Number;
-                playoutOffset = channel.PlayoutOffset ?? TimeSpan.Zero;
-            }
-
-            List<Playout> playouts = await dbContext.Playouts
-                .AsNoTracking()
-                .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Studios)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Directors)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artists)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .AsSplitQuery()
-                .ToListAsync(cancellationToken);
-
-            await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
-            await using var xml = XmlWriter.Create(
-                ms,
-                new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
-
-            int daysToBuild = await _configElementRepository
-                .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
-                .IfNoneAsync(2);
-
-            DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
-
-            foreach (Playout playout in playouts)
-            {
-                switch (playout.ScheduleKind)
-                {
-                    case PlayoutScheduleKind.Classic:
-                    case PlayoutScheduleKind.Sequential:
-                    case PlayoutScheduleKind.Scripted:
-                        var floodSorted = playouts
-                            .Collect(p => p.Items)
-                            .OrderBy(pi => pi.Start)
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in floodSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WritePlayoutXml(
-                            request,
-                            floodSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                    case PlayoutScheduleKind.Block:
-                        var blockSorted = playouts
-                            .Collect(p => p.Items)
-                            .OrderBy(pi => pi.Start)
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in blockSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WriteBlockPlayoutXml(
-                            request,
-                            blockSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                    case PlayoutScheduleKind.ExternalJson:
-                        var externalJsonSorted = (await CollectExternalJsonItems(playout.ScheduleFile))
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in externalJsonSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WritePlayoutXml(
-                            request,
-                            externalJsonSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                }
-            }
-
-            await xml.FlushAsync();
-
-            string tempFile = Path.GetTempFileName();
-            await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
-
-            File.Move(tempFile, targetFile, true);
+            return;
         }
-        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
+
+        var minifier = new XmlMinifier(
+            new XmlMinificationSettings
+            {
+                MinifyWhitespace = true,
+                RemoveXmlComments = true,
+                CollapseTagsWithoutContent = true
+            });
+
+        var templateContext = new XmlTemplateContext();
+
+        string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
+        var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
+
+        string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
+        var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
+
+        string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
+        var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
+
+        string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
+        var songTemplate = Template.Parse(songText, songTemplateFileName);
+
+        string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
+        var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<Playout> playouts = await dbContext.Playouts
+            .AsNoTracking()
+            .Filter(pi => pi.Channel.Number == request.ChannelNumber)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Studios)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Directors)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artists)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .ToListAsync(cancellationToken);
+
+        await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+        await using var xml = XmlWriter.Create(
+            ms,
+            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+        int daysToBuild = await _configElementRepository
+            .GetValue<int>(ConfigElementKey.XmltvDaysToBuild)
+            .IfNoneAsync(2);
+
+        DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
+
+        foreach (Playout playout in playouts)
         {
-            // do nothing
+            switch (playout.ProgramSchedulePlayoutType)
+            {
+                case ProgramSchedulePlayoutType.Flood:
+                case ProgramSchedulePlayoutType.Yaml:
+                    var floodSorted = playouts
+                        .Collect(p => p.Items)
+                        .OrderBy(pi => pi.Start)
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+                    await WritePlayoutXml(
+                        request,
+                        floodSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+                case ProgramSchedulePlayoutType.Block:
+                    var blockSorted = playouts
+                        .Collect(p => p.Items)
+                        .OrderBy(pi => pi.Start)
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+                    await WriteBlockPlayoutXml(
+                        request,
+                        blockSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+                case ProgramSchedulePlayoutType.ExternalJson:
+                    var externalJsonSorted = (await CollectExternalJsonItems(playout.ExternalJsonFile))
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+
+                    await WritePlayoutXml(
+                        request,
+                        externalJsonSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+            }
         }
+
+        await xml.FlushAsync();
+
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
+        File.Move(tempFile, targetFile, true);
     }
 
     private async Task WritePlayoutXml(
@@ -333,13 +257,11 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
+        XmlWriter xml)
     {
         XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
+            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone)
             .IfNoneAsync(XmltvTimeZone.Local);
 
         // skip all filler that isn't pre-roll
@@ -365,12 +287,24 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             int finishIndex = j;
             while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
                                                       || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
-                                                          or FillerKind.PostRoll or FillerKind.Tail
-                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
+                                                          or FillerKind.Tail or FillerKind.Fallback or FillerKind.DecoDefault))
             {
                 finishIndex++;
             }
 
+            int customShowId = -1;
+            if (displayItem.MediaItem is Episode ep)
+            {
+                customShowId = ep.Season.ShowId;
+            }
+
+            bool isSameCustomShow = hasCustomTitle;
+            for (int x = j; x <= finishIndex; x++)
+            {
+                isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
+                                   customShowId == e.Season.ShowId;
+            }
+
             PlayoutItem finishItem = sorted[finishIndex];
             i = finishIndex;
 
@@ -408,7 +342,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 musicVideoTemplate,
                 songTemplate,
                 otherVideoTemplate,
-                remoteStreamTemplate,
                 minifier,
                 xml);
 
@@ -416,7 +349,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         }
     }
 
-    private async Task WriteBlockPlayoutXml(
+    private static async Task WriteBlockPlayoutXml(
         RefreshChannelData request,
         List<PlayoutItem> sorted,
         XmlTemplateContext templateContext,
@@ -425,110 +358,51 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
+        XmlWriter xml)
     {
-        XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
-            .IfNoneAsync(XmltvTimeZone.Local);
-
-        XmltvBlockBehavior xmltvBlockBehavior = await _configElementRepository
-            .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
-            .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);
-
         var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
         foreach (var group in groups)
         {
+            DateTime groupStart = group.Key.GuideStart!.Value;
+            DateTime groupFinish = group.Key.GuideFinish!.Value;
+            TimeSpan groupDuration = groupFinish - groupStart;
+
             var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
             if (itemsToInclude.Count == 0)
             {
                 continue;
             }
 
-            switch (xmltvBlockBehavior)
+            TimeSpan perItem = groupDuration / itemsToInclude.Count;
+
+            DateTimeOffset currentStart = new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime();
+            DateTimeOffset currentFinish = currentStart + perItem;
+
+            foreach (PlayoutItem item in itemsToInclude)
             {
-                case XmltvBlockBehavior.UseActualTimes:
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        DateTimeOffset actualStart = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
-                        };
+                string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty);
+                string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty);
 
-                        DateTimeOffset actualFinish = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
-                        };
+                await WriteItemToXml(
+                    request,
+                    item,
+                    start,
+                    stop,
+                    false,
+                    templateContext,
+                    movieTemplate,
+                    episodeTemplate,
+                    musicVideoTemplate,
+                    songTemplate,
+                    otherVideoTemplate,
+                    minifier,
+                    xml);
 
-                        string start = actualStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = actualFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-                    }
-                    break;
-                case XmltvBlockBehavior.SplitTimeEvenly:
-                default:
-                    DateTime groupStart = group.Key.GuideStart!.Value;
-                    DateTime groupFinish = group.Key.GuideFinish!.Value;
-                    TimeSpan groupDuration = groupFinish - groupStart;
-
-                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
-
-                    DateTimeOffset currentStart = xmltvTimeZone switch
-                    {
-                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
-                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
-                    };
-
-                    DateTimeOffset currentFinish = currentStart + perItem;
-
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-
-                        currentStart = currentFinish;
-                        currentFinish += perItem;
-                    }
-                    break;
+                currentStart = currentFinish;
+                currentFinish += perItem;
             }
         }
     }
@@ -545,7 +419,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
         XmlWriter xml)
     {
@@ -607,16 +480,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 title,
                 templateContext,
                 otherVideoTemplate),
-            RemoteStream templateRemoteStream => await ProcessRemoteStreamTemplate(
-                request,
-                templateRemoteStream,
-                start,
-                stop,
-                hasCustomTitle,
-                displayItem,
-                title,
-                templateContext,
-                remoteStreamTemplate),
             _ => Option<string>.None
         };
 
@@ -704,7 +567,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 showMetadata.Guids ??= [];
 
                 string artworkPath = GetPrioritizedArtworkPath(showMetadata);
-                string thumbnailPath = GetPrioritizedArtworkPath(metadata);
 
                 var data = new
                 {
@@ -725,8 +587,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                     ShowGenres = showMetadata.Genres.Map(g => g.Name).OrderBy(n => n),
                     EpisodeHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
                     EpisodeArtworkUrl = artworkPath,
-                    EpisodeHasThumbnail = !string.IsNullOrWhiteSpace(thumbnailPath),
-                    EpisodeThumbnailUrl = thumbnailPath,
                     SeasonNumber = templateEpisode.Season?.SeasonNumber ?? 0,
                     metadata.EpisodeNumber,
                     ShowHasContentRating = !string.IsNullOrWhiteSpace(showMetadata.ContentRating),
@@ -883,8 +743,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             metadata.Genres ??= [];
             metadata.Guids ??= [];
 
-            string artworkPath = GetPrioritizedArtworkPath(metadata);
-
             var data = new
             {
                 ProgrammeStart = start,
@@ -899,8 +757,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 OtherVideoPlot = metadata.Plot,
                 OtherVideoHasYear = metadata.Year.HasValue,
                 OtherVideoYear = metadata.Year,
-                OtherVideoHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                OtherVideoArtworkUrl = artworkPath,
                 OtherVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
                 OtherVideoHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
                 OtherVideoContentRating = metadata.ContentRating
@@ -916,63 +772,18 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return Option<string>.None;
     }
 
-    private static async Task<Option<string>> ProcessRemoteStreamTemplate(
-        RefreshChannelData request,
-        RemoteStream templateRemoteStream,
-        string start,
-        string stop,
-        bool hasCustomTitle,
-        PlayoutItem displayItem,
-        string title,
-        XmlTemplateContext templateContext,
-        Template remoteStreamTemplate)
-    {
-        foreach (RemoteStreamMetadata metadata in templateRemoteStream.RemoteStreamMetadata.HeadOrNone())
-        {
-            metadata.Genres ??= [];
-            metadata.Guids ??= [];
-
-            string artworkPath = GetPrioritizedArtworkPath(metadata);
-
-            var data = new
-            {
-                ProgrammeStart = start,
-                ProgrammeStop = stop,
-                ChannelId = ChannelIdentifier.FromNumber(request.ChannelNumber),
-                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(request.ChannelNumber),
-                request.ChannelNumber,
-                HasCustomTitle = hasCustomTitle,
-                displayItem.CustomTitle,
-                RemoteStreamTitle = title,
-                RemoteStreamHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
-                RemoteStreamPlot = metadata.Plot,
-                RemoteStreamHasYear = metadata.Year.HasValue,
-                RemoteStreamYear = metadata.Year,
-                RemoteStreamHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                RemoteStreamArtworkUrl = artworkPath,
-                RemoteStreamGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
-                RemoteStreamHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
-                RemoteStreamContentRating = metadata.ContentRating
-            };
-
-            var scriptObject = new ScriptObject();
-            scriptObject.Import(data);
-            templateContext.PushGlobal(scriptObject);
-
-            return await remoteStreamTemplate.RenderAsync(templateContext);
-        }
-
-        return Option<string>.None;
-    }
-
     private string GetMovieTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "movie.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "movie.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_movie.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate movie XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -986,12 +797,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetEpisodeTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "episode.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "episode.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_episode.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate episode XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1005,12 +820,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetMusicVideoTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "musicVideo.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "musicVideo.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_musicVideo.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate music video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1024,12 +843,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetSongTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "song.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "song.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_song.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate song XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1043,12 +866,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetOtherVideoTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "otherVideo.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "otherVideo.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_otherVideo.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate other video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1060,25 +887,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return templateFileName;
     }
 
-    private string GetRemoteStreamTemplateFileName()
-    {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "remoteStream.sbntxt");
-
-        // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
-        {
-            _logger.LogError(
-                "Unable to generate remote stream XMLTV fragment without template file {File}; please restart ErsatzTV",
-                templateFileName);
-
-            return null;
-        }
-
-        return templateFileName;
-    }
-
     private static string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
     {
         string artworkPath = artwork.Path;
@@ -1134,8 +942,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 .IfNone("[unknown artist]"),
             OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
                 .IfNone("[unknown video]"),
-            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown remote stream]"),
             _ => "[unknown]"
         };
     }
@@ -1184,7 +990,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     {
         var result = new List<PlayoutItem>();
 
-        if (_fileSystem.File.Exists(path))
+        if (_localFileSystem.FileExists(path))
         {
             Option<ExternalJsonChannel> maybeChannel = JsonConvert.DeserializeObject<ExternalJsonChannel>(
                 await File.ReadAllTextAsync(path));

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -1,10 +1,8 @@
 using System.Data.Common;
-using System.IO.Abstractions;
 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;
@@ -20,7 +18,6 @@ namespace ErsatzTV.Application.Channels;
 public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelListHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -28,13 +25,11 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
     public RefreshChannelListHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         ILogger<RefreshChannelListHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _logger = logger;
     }
@@ -48,13 +43,13 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "channel.sbntxt");
 
         // fall back to default template
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
         }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate channel list without template file {File}; please restart ErsatzTV",
@@ -82,9 +77,6 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 
         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),
@@ -92,8 +84,7 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
                 ChannelNumber = channel.Number,
                 ChannelName = channel.Name,
                 ChannelCategories = GetCategories(channel.Categories),
-                ChannelHasExternalArtwork = hasExternalLogo,
-                ChannelHasArtwork = hasLogo,
+                ChannelHasArtwork = !string.IsNullOrWhiteSpace(channel.ArtworkPath),
                 ChannelArtworkPath = channel.ArtworkPath,
                 ChannelNameEncoded = WebUtility.UrlEncode(channel.Name)
             };
@@ -122,7 +113,7 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         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) or C.MirrorSourceChannelId in (select ChannelId from Playout)) and C.IsEnabled = 1 and C.ShowInEPG = 1
+                               where C.Id in (select ChannelId from Playout)
                                order by CAST(C.Number as double)";
         // TODO: this needs to be fixed for sqlite/mariadb
 

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -11,16 +10,10 @@ public record UpdateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    double? SlugSeconds,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -28,8 +21,4 @@ public record UpdateChannel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg) : IRequest<Either<BaseError, ChannelViewModel>>;
+    ChannelSongVideoMode SongVideoMode) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -24,37 +24,17 @@ public class UpdateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
-    private async Task<ChannelViewModel> ApplyUpdateRequest(
-        TvContext dbContext,
-        Channel c,
-        UpdateChannel update,
-        CancellationToken cancellationToken)
+    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
     {
-        // don't save mirror when playout exists
-        if (c.Playouts.Count > 0)
-        {
-            update = update with
-            {
-                PlayoutSource = ChannelPlayoutSource.Generated,
-                MirrorSourceChannelId = null
-            };
-        }
-
-        bool hasEpgChange = c.PlayoutSource != update.PlayoutSource || c.ShowInEpg != update.ShowInEpg;
-
         c.Name = update.Name;
         c.Number = update.Number;
-        c.SortNumber = double.Parse(update.Number, CultureInfo.InvariantCulture);
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
-        c.SlugSeconds = update.SlugSeconds;
-        c.StreamSelectorMode = update.StreamSelectorMode;
-        c.StreamSelector = update.StreamSelector;
         c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
         c.PreferredAudioTitle = update.PreferredAudioTitle;
         c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
@@ -62,177 +42,80 @@ public class UpdateChannelHandler(
         c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
         c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
         c.SongVideoMode = update.SongVideoMode;
-        c.TranscodeMode = update.TranscodeMode;
-        c.IdleBehavior = update.IdleBehavior;
-        c.IsEnabled = update.IsEnabled;
-        c.ShowInEpg = update.IsEnabled && update.ShowInEpg;
-        c.Artwork ??= [];
+        c.Artwork ??= new List<Artwork>();
 
-        if (!string.IsNullOrWhiteSpace(update.Logo?.Path))
+        if (!string.IsNullOrWhiteSpace(update.Logo))
         {
-            string logo = update.Logo.Path;
-            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
-            {
-                logo = logo.Replace("iptv/logos/", string.Empty);
-            }
+            Option<Artwork> maybeLogo =
+                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
 
-            Option<Artwork> maybeLogo = c.Artwork.Where(a => a.ArtworkKind == ArtworkKind.Logo).HeadOrNone();
-            foreach (Artwork artwork in maybeLogo)
-            {
-                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
+            maybeLogo.Match(
+                artwork =>
                 {
-                    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(cancellationToken);
-
-            foreach (Artwork artwork in c.Artwork.Where(x => x.ArtworkKind is ArtworkKind.Logo).ToList())
-            {
-                c.Artwork.Remove(artwork);
-                dbContext.Artwork.Remove(artwork);
-            }
+                    artwork.Path = update.Logo;
+                    artwork.DateUpdated = DateTime.UtcNow;
+                },
+                () =>
+                {
+                    var artwork = new Artwork
+                    {
+                        Path = update.Logo,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow,
+                        ArtworkKind = ArtworkKind.Logo
+                    };
+                    c.Artwork.Add(artwork);
+                });
         }
 
-        c.PlayoutSource = update.PlayoutSource;
-        c.PlayoutMode = update.PlayoutMode;
-
-        if (c.PlayoutSource is ChannelPlayoutSource.Mirror)
-        {
-            c.PlayoutMode = ChannelPlayoutMode.Continuous;
-            hasEpgChange |= c.MirrorSourceChannelId != update.MirrorSourceChannelId;
-            hasEpgChange |= c.PlayoutOffset != update.PlayoutOffset;
-        }
-        else
-        {
-            c.MirrorSourceChannelId = null;
-            c.PlayoutOffset = null;
-        }
-
-        c.MirrorSourceChannelId = update.MirrorSourceChannelId;
-        c.PlayoutOffset = update.PlayoutOffset;
+        c.ProgressMode = update.ProgressMode;
         c.StreamingMode = update.StreamingMode;
         c.WatermarkId = update.WatermarkId;
         c.FallbackFillerId = update.FallbackFillerId;
-
-        await dbContext.SaveChangesAsync(cancellationToken);
+        await dbContext.SaveChangesAsync();
 
         searchTargets.SearchTargetsChanged();
 
         if (c.SubtitleMode != ChannelSubtitleMode.None)
         {
             Option<Playout> maybePlayout = await dbContext.Playouts
-                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id, cancellationToken);
+                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id);
 
             foreach (Playout playout in maybePlayout)
             {
-                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), cancellationToken);
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
             }
         }
 
-        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
-        if (hasEpgChange)
-        {
-            await workerChannel.WriteAsync(new RefreshChannelData(c.Number), cancellationToken);
-        }
+        await workerChannel.WriteAsync(new RefreshChannelList());
 
-        return ProjectToViewModel(c, c.Playouts?.Count ?? 0);
+        return ProjectToViewModel(c);
     }
 
-    private static async Task<Validation<BaseError, Channel>> Validate(
-        TvContext dbContext,
-        UpdateChannel request,
-        CancellationToken cancellationToken) =>
-        (await ChannelMustExist(dbContext, request, cancellationToken),
-            ValidateName(request),
-            await ValidateNumber(dbContext, request, cancellationToken),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
-        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+        (await ChannelMustExist(dbContext, request), ValidateName(request),
+            await ValidateNumber(dbContext, request))
+        .Apply((channelToUpdate, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        UpdateChannel updateChannel,
-        CancellationToken cancellationToken) =>
+        UpdateChannel updateChannel) =>
         dbContext.Channels
             .Include(c => c.Artwork)
             .Include(c => c.Watermark)
-            .Include(c => c.Playouts)
-            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId, cancellationToken)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
             .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
 
-    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
-        TvContext dbContext,
-        UpdateChannel request,
-        CancellationToken cancellationToken)
-    {
-        if (request.PlayoutSource is not ChannelPlayoutSource.Mirror)
-        {
-            return Unit.Default;
-        }
-
-        Option<Channel> maybeMirrorSource = await dbContext.Channels
-            .AsNoTracking()
-            .SelectOneAsync(
-                c => c.Id == request.MirrorSourceChannelId,
-                c => c.Id == request.MirrorSourceChannelId,
-                cancellationToken);
-
-        if (maybeMirrorSource.IsNone)
-        {
-            return BaseError.New("Mirror source channel does not exist.");
-        }
-
-        foreach (var mirrorSource in maybeMirrorSource)
-        {
-            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
-            {
-                return BaseError.New(
-                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
-            }
-        }
-
-        foreach (TimeSpan playoutOffset in Optional(request.PlayoutOffset))
-        {
-            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
-            {
-                return BaseError.New("Playout offset must not be greater than 12 hours");
-            }
-        }
-
-        return Unit.Default;
-    }
-
     private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
         updateChannel.NotEmpty(c => c.Name)
             .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        UpdateChannel updateChannel,
-        CancellationToken cancellationToken)
+        UpdateChannel updateChannel)
     {
         int matchId = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number, cancellationToken)
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
             .Match(c => c.Id, () => updateChannel.ChannelId);
 
         if (matchId == updateChannel.ChannelId)

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbers.cs

@@ -1,5 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Channels;
-
-public record UpdateChannelNumbers(List<ChannelSortViewModel> Channels) : IRequest<Option<BaseError>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbersHandler.cs

@@ -1,72 +0,0 @@
-using System.Globalization;
-using System.Threading.Channels;
-using ErsatzTV.Core;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Channel = ErsatzTV.Core.Domain.Channel;
-
-namespace ErsatzTV.Application.Channels;
-
-public class UpdateChannelNumbersHandler(
-    IDbContextFactory<TvContext> dbContextFactory,
-    ChannelWriter<IBackgroundServiceRequest> workerChannel)
-    : IRequestHandler<UpdateChannelNumbers, Option<BaseError>>
-{
-    public async Task<Option<BaseError>> Handle(UpdateChannelNumbers request, CancellationToken cancellationToken)
-    {
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
-
-        try
-        {
-            var numberUpdates = request.Channels.ToDictionary(c => c.Id, c => c.Number);
-            var channelIds = numberUpdates.Keys;
-
-            List<Channel> channelsToUpdate = await dbContext.Channels
-                .Where(c => channelIds.Contains(c.Id))
-                .ToListAsync(cancellationToken);
-
-            // give every channel a non-conflicting number
-            foreach (var channel in channelsToUpdate)
-            {
-                channel.Number = $"-{channel.Id}";
-            }
-
-            // save those changes
-            await dbContext.SaveChangesAsync(cancellationToken);
-
-            // give every channel the proper new number
-            foreach (var channel in channelsToUpdate)
-            {
-                channel.Number = numberUpdates[channel.Id];
-                if (double.TryParse(channel.Number, CultureInfo.InvariantCulture, out double sortNumber))
-                {
-                    channel.SortNumber = sortNumber;
-                }
-                else
-                {
-                    return BaseError.New($"Failed to parse channel number {channel.Number}");
-                }
-            }
-
-            // save those changes
-            await dbContext.SaveChangesAsync(cancellationToken);
-
-            // commit the transaction
-            await transaction.CommitAsync(cancellationToken);
-
-            // update channel list and xmltv
-            await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
-            foreach (var channel in channelsToUpdate)
-            {
-                await workerChannel.WriteAsync(new RefreshChannelData(channel.Number), cancellationToken);
-            }
-
-            return Option<BaseError>.None;
-        }
-        catch (Exception ex)
-        {
-            return BaseError.New("Failed to update channel numbers: " + ex.Message);
-        }
-    }
-}

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,12 +1,11 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
 internal static class Mapper
 {
-    internal static ChannelViewModel ProjectToViewModel(Channel channel, int playoutCount) =>
+    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
         new(
             channel.Id,
             channel.Number,
@@ -14,29 +13,19 @@ internal static class Mapper
             channel.Group,
             channel.Categories,
             channel.FFmpegProfileId,
-            channel.SlugSeconds,
             GetLogo(channel),
-            channel.StreamSelectorMode,
-            channel.StreamSelector,
             channel.PreferredAudioLanguageCode,
             channel.PreferredAudioTitle,
-            channel.PlayoutSource,
-            channel.PlayoutMode,
-            channel.MirrorSourceChannelId,
-            channel.PlayoutOffset,
+            channel.ProgressMode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
-            playoutCount,
+            channel.Playouts?.Count ?? 0,
             channel.PreferredSubtitleLanguageCode,
             channel.SubtitleMode,
             channel.MusicVideoCreditsMode,
             channel.MusicVideoCreditsTemplate,
-            channel.SongVideoMode,
-            channel.TranscodeMode,
-            channel.IdleBehavior,
-            channel.IsEnabled,
-            channel.ShowInEpg);
+            channel.SongVideoMode);
 
     internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
         new(
@@ -50,30 +39,12 @@ internal static class Mapper
     internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
         new(resolution.Height, resolution.Width);
 
-    internal static ChannelStreamingSpecsViewModel ProjectToSpecsViewModel(Channel channel) =>
-        new(
-            channel.FFmpegProfile.Resolution.Height,
-            channel.FFmpegProfile.Resolution.Width,
-            (int)((channel.FFmpegProfile.VideoBitrate * 1000 + channel.FFmpegProfile.AudioBitrate * 1000) * 1.2),
-            channel.FFmpegProfile.VideoFormat,
-            channel.FFmpegProfile.VideoProfile,
-            channel.FFmpegProfile.AudioFormat);
+    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 GetLogo(Channel channel) =>
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+            .Match(a => a.Path, string.Empty);
 
     private static string GetStreamingMode(Channel channel) =>
         channel.StreamingMode switch
@@ -82,6 +53,7 @@ internal static class Mapper
             StreamingMode.TransportStreamHybrid => "MPEG-TS",
             StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
             StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
+            StreamingMode.HttpLiveStreamingSegmenterV2 => "HLS Segmenter V2",
             _ => throw new ArgumentOutOfRangeException(nameof(channel))
         };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

@@ -1,3 +1,3 @@
 namespace ErsatzTV.Application.Channels;
 
-public record GetAllChannels(bool ShowDisabled = true) : IRequest<List<ChannelViewModel>>;
+public record GetAllChannels : IRequest<List<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSort.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSortHandler.cs

@@ -1,31 +0,0 @@
-using System.Globalization;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-
-namespace ErsatzTV.Application.Channels;
-
-public class GetAllChannelsForSortHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetAllChannelsForSort, List<ChannelSortViewModel>>
-{
-    public async Task<List<ChannelSortViewModel>> Handle(
-        GetAllChannelsForSort request,
-        CancellationToken cancellationToken)
-    {
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        return await dbContext.Channels
-            .AsNoTracking()
-            .ToListAsync(cancellationToken)
-            .Map(list => list.Map(ProjectToSortViewModel)
-                .OrderBy(c => decimal.Parse(c.Number, CultureInfo.InvariantCulture)).ToList());
-    }
-
-    private static ChannelSortViewModel ProjectToSortViewModel(Channel channel)
-        => new()
-        {
-            Id = channel.Id,
-            Number = channel.Number,
-            Name = channel.Name,
-            OriginalNumber = channel.Number
-        };
-}

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -1,31 +1,14 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetAllChannelsHandler(IChannelRepository channelRepository)
-    : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
+public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
+    private readonly IChannelRepository _channelRepository;
+
+    public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
     public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-        await channelRepository.GetAll(cancellationToken)
-            .Map(list => list.Where(c => c.IsEnabled || request.ShowDisabled)
-                .Map(c => ProjectToViewModel(c, GetPlayoutsCount(c))).ToList());
-
-    private static int GetPlayoutsCount(Channel channel)
-    {
-        var result = 0;
-
-        if (channel.Playouts != null)
-        {
-            result += channel.Playouts.Count;
-        }
-
-        if (channel.PlayoutSource is ChannelPlayoutSource.Mirror && channel.MirrorSourceChannel?.Playouts != null)
-        {
-            result += channel.MirrorSourceChannel.Playouts.Count;
-        }
-
-        return result;
-    }
+        Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
 }

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutIdHandler.cs

@@ -1,21 +0,0 @@
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using static ErsatzTV.Application.Channels.Mapper;
-
-namespace ErsatzTV.Application.Channels;
-
-public class GetChannelByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetChannelByPlayoutId, Option<ChannelViewModel>>
-{
-    public async Task<Option<ChannelViewModel>> Handle(
-        GetChannelByPlayoutId request,
-        CancellationToken cancellationToken)
-    {
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        return await dbContext.Playouts
-            .Include(p => p.Channel)
-            .ThenInclude(c => c.Artwork)
-            .SingleOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken)
-            .Map(p => ProjectToViewModel(p.Channel, 1));
-    }
-}

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,7 +1,4 @@
-using System.Collections.Immutable;
-using System.IO.Abstractions;
 using System.Text;
-using System.Text.RegularExpressions;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Iptv;
@@ -11,32 +8,35 @@ using Microsoft.IO;
 
 namespace ErsatzTV.Application.Channels;
 
-public partial class GetChannelGuideHandler(
-    IDbContextFactory<TvContext> dbContextFactory,
-    RecyclableMemoryStreamManager recyclableMemoryStreamManager,
-    IFileSystem fileSystem,
-    ILocalFileSystem localFileSystem)
-    : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
+public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
 {
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public GetChannelGuideHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        ILocalFileSystem localFileSystem)
+    {
+        _dbContextFactory = dbContextFactory;
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _localFileSystem = localFileSystem;
+    }
+
     public async Task<Either<BaseError, ChannelGuide>> Handle(
         GetChannelGuide request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        var hiddenChannelNumbers = dbContext.Channels
-            .Where(c => c.ShowInEpg == false)
-            .Select(c => c.Number)
-            .AsEnumerable()
-            .Select(n => $"{n}.xml")
-            .ToImmutableHashSet();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        string channelsFile = fileSystem.Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
-        if (!fileSystem.File.Exists(channelsFile))
+        string channelsFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        if (!_localFileSystem.FileExists(channelsFile))
         {
             return BaseError.New($"Required file {channelsFile} is missing");
         }
 
-        long mtime = fileSystem.File.GetLastWriteTime(channelsFile).Ticks;
+        long mtime = File.GetLastWriteTime(channelsFile).Ticks;
 
         var accessTokenUri = $"?v={mtime}";
         if (!string.IsNullOrWhiteSpace(request.AccessToken))
@@ -44,7 +44,7 @@ public partial class GetChannelGuideHandler(
             accessTokenUri += $"&amp;access_token={request.AccessToken}";
         }
 
-        string channelsFragment = await ReadAllTextShared(channelsFile, cancellationToken);
+        string channelsFragment = await File.ReadAllTextAsync(channelsFile, Encoding.UTF8, cancellationToken);
 
         // TODO: is regex faster?
         channelsFragment = channelsFragment
@@ -53,54 +53,22 @@ public partial class GetChannelGuideHandler(
 
         var channelDataFragments = new Dictionary<string, string>();
 
-        foreach (string fileName in localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
+        foreach (string fileName in _localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
         {
             if (fileName.Contains("channels"))
             {
                 continue;
             }
 
-            if (hiddenChannelNumbers.Contains(fileSystem.Path.GetFileName(fileName)))
-            {
-                continue;
-            }
+            string channelDataFragment = await File.ReadAllTextAsync(fileName, Encoding.UTF8, cancellationToken);
 
-            try
-            {
-                string channelDataFragment = await ReadAllTextShared(fileName, cancellationToken);
+            channelDataFragment = channelDataFragment
+                .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+                .Replace("{AccessTokenUri}", accessTokenUri);
 
-                channelDataFragment = channelDataFragment
-                    .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
-                    .Replace("{AccessTokenUri}", accessTokenUri);
-
-                channelDataFragment = EtvTagRegex().Replace(channelDataFragment, string.Empty);
-
-                channelDataFragments.Add(fileSystem.Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
-            }
-            catch (FileNotFoundException)
-            {
-                // ignore this channel fragment
-            }
-            catch (IOException)
-            {
-                // ignore this channel fragment
-            }
+            channelDataFragments.Add(Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
         }
 
-        return new ChannelGuide(recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
+        return new ChannelGuide(_recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
     }
-
-    private async Task<string> ReadAllTextShared(string fileName, CancellationToken cancellationToken)
-    {
-        await using var stream = fileSystem.FileStream.New(
-            fileName,
-            FileMode.Open,
-            FileAccess.Read,
-            FileShare.ReadWrite);
-        using var reader = new StreamReader(stream, Encoding.UTF8, leaveOpen: true);
-        return await reader.ReadToEndAsync(cancellationToken);
-    }
-
-    [GeneratedRegex(@"<etv:[^>]+?>.*?<\/etv:[^>]+?>|<etv:[^>]+?\/>", RegexOptions.Singleline)]
-    private static partial Regex EtvTagRegex();
 }

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

@@ -10,7 +10,6 @@ public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<Li
     public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
     public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAll(cancellationToken)
-            .Map(channels => channels.Where(c => c.IsEnabled)
-                .Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
+        _channelRepository.GetAll()
+            .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
 }

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -4,36 +4,40 @@ using ErsatzTV.Core.Iptv;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelPlaylistHandler(IChannelRepository channelRepository)
-    : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
+
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-        channelRepository.GetAll(cancellationToken)
+        _channelRepository.GetAll()
             .Map(channels => EnsureMode(channels, request.Mode))
-            .Map(channels => new ChannelPlaylist(
-                request.Scheme,
-                request.Host,
-                request.BaseUrl,
-                channels,
-                request.UserAgent,
-                request.AccessToken));
+            .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.IsEnabled)
-            {
-                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

@@ -5,11 +5,11 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetChannelStreamingSpecs, Option<ChannelStreamingSpecsViewModel>>
+public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelResolutionAndBitrate, Option<ResolutionAndBitrateViewModel>>
 {
-    public async Task<Option<ChannelStreamingSpecsViewModel>> Handle(
-        GetChannelStreamingSpecs request,
+    public async Task<Option<ResolutionAndBitrateViewModel>> Handle(
+        GetChannelResolutionAndBitrate request,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
@@ -18,8 +18,10 @@ public class GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbCont
             .AsNoTracking()
             .Include(c => c.FFmpegProfile)
             .ThenInclude(ff => ff.Resolution)
-            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber, cancellationToken);
+            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber);
 
-        return maybeChannel.Map(Mapper.ProjectToSpecsViewModel);
+        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

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectorsHandler.cs

@@ -1,14 +0,0 @@
-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/Queries/GetChannelStreamingSpecs.cs

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

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumberHandler.cs

@@ -1,17 +0,0 @@
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-
-namespace ErsatzTV.Application.Channels;
-
-public class GetSlugSecondsByChannelNumberHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetSlugSecondsByChannelNumber, Option<double>>
-{
-    public async Task<Option<double>> Handle(GetSlugSecondsByChannelNumber request, CancellationToken cancellationToken)
-    {
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        return await dbContext.Channels
-            .AsNoTracking()
-            .SingleOrDefaultAsync(c => c.Number == request.ChannelNumber, cancellationToken)
-            .Map(c => Optional(c?.SlugSeconds));
-    }
-}

ErsatzTV.Application/Channels/ResolutionAndBitrateViewModel.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -4,12 +4,12 @@ using ErsatzTV.Core.Interfaces.Repositories;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSettings, Either<BaseError, Unit>>
+public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly LoggingLevelSwitches _loggingLevelSwitches;
 
-    public UpdateLoggingSettingsHandler(
+    public UpdateGeneralSettingsHandler(
         LoggingLevelSwitches loggingLevelSwitches,
         IConfigElementRepository configElementRepository)
     {
@@ -18,38 +18,33 @@ public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSetting
     }
 
     public async Task<Either<BaseError, Unit>> Handle(
-        UpdateLoggingSettings request,
-        CancellationToken cancellationToken) => await ApplyUpdate(request.LoggingSettings, cancellationToken);
+        UpdateGeneralSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.GeneralSettings);
 
-    private async Task<Unit> ApplyUpdate(LoggingSettingsViewModel loggingSettings, CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, loggingSettings.DefaultMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = loggingSettings.DefaultMinimumLogLevel;
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.DefaultMinimumLogLevel);
+        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = generalSettings.DefaultMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelScanning,
-            loggingSettings.ScanningMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = loggingSettings.ScanningMinimumLogLevel;
+            generalSettings.ScanningMinimumLogLevel);
+        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = generalSettings.ScanningMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelScheduling,
-            loggingSettings.SchedulingMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = loggingSettings.SchedulingMinimumLogLevel;
-
-        await _configElementRepository.Upsert(
-            ConfigElementKey.MinimumLogLevelSearching,
-            loggingSettings.SearchingMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.SearchingLevelSwitch.MinimumLevel = loggingSettings.SearchingMinimumLogLevel;
+            generalSettings.SchedulingMinimumLogLevel);
+        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = generalSettings.SchedulingMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelStreaming,
-            loggingSettings.StreamingMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = loggingSettings.StreamingMinimumLogLevel;
+            generalSettings.StreamingMinimumLogLevel);
+        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = generalSettings.StreamingMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelHttp,
-            loggingSettings.HttpMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = loggingSettings.HttpMinimumLogLevel;
+            generalSettings.HttpMinimumLogLevel);
+        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = generalSettings.HttpMinimumLogLevel;
 
         return Unit.Default;
     }

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -16,16 +16,16 @@ public class UpdateLibraryRefreshIntervalHandler :
         UpdateLibraryRefreshInterval request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(_ => _configElementRepository.Upsert(
-                ConfigElementKey.LibraryRefreshInterval,
-                request.LibraryRefreshInterval,
-                cancellationToken))
+            .MapT(
+                _ => _configElementRepository.Upsert(
+                    ConfigElementKey.LibraryRefreshInterval,
+                    request.LibraryRefreshInterval))
             .Bind(v => v.ToEitherAsync());
 
     private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
         Optional(request.LibraryRefreshInterval)
             .Where(lri => lri is >= 0 and < 1_000_000)
             .Map(_ => Unit.Default)
-            .ToValidation<BaseError>("Library refresh interval must be zero or greater")
+            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
             .AsTask();
 }

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -32,40 +32,24 @@ public class UpdatePlayoutSettingsHandler : IRequestHandler<UpdatePlayoutSetting
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Unit> validation = await Validate(request);
-        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(
-            dbContext,
-            request.PlayoutSettings,
-            cancellationToken));
+        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.PlayoutSettings));
     }
 
-    private async Task<Unit> ApplyUpdate(
-        TvContext dbContext,
-        PlayoutSettingsViewModel playoutSettings,
-        CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(TvContext dbContext, PlayoutSettingsViewModel playoutSettings)
     {
-        await _configElementRepository.Upsert(
-            ConfigElementKey.PlayoutDaysToBuild,
-            playoutSettings.DaysToBuild,
-            cancellationToken);
-
+        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, playoutSettings.DaysToBuild);
         await _configElementRepository.Upsert(
             ConfigElementKey.PlayoutSkipMissingItems,
-            playoutSettings.SkipMissingItems,
-            cancellationToken);
-
-        await _configElementRepository.Upsert(
-            ConfigElementKey.PlayoutScriptedScheduleTimeoutSeconds,
-            playoutSettings.ScriptedScheduleTimeoutSeconds,
-            cancellationToken);
+            playoutSettings.SkipMissingItems);
 
         // continue all playouts to proper number of days
         List<Playout> playouts = await dbContext.Playouts
             .Include(p => p.Channel)
-            .ToListAsync(cancellationToken);
+            .ToListAsync();
         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), cancellationToken);
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
         }
 
         return Unit.Default;

ErsatzTV.Application/Configuration/Commands/UpdateUiSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateUiSettingsHandler.cs

@@ -1,28 +0,0 @@
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-
-namespace ErsatzTV.Application.Configuration;
-
-public class UpdateUiSettingsHandler(IConfigElementRepository configElementRepository)
-    : IRequestHandler<UpdateUiSettings, Either<BaseError, Unit>>
-{
-    public async Task<Either<BaseError, Unit>> Handle(
-        UpdateUiSettings request,
-        CancellationToken cancellationToken)
-    {
-        return await ApplyUpdate(request.UiSettings, cancellationToken);
-    }
-
-    private async Task<Unit> ApplyUpdate(UiSettingsViewModel uiSettings, CancellationToken cancellationToken)
-    {
-        await configElementRepository.Upsert(
-            ConfigElementKey.PagesIsDarkMode,
-            uiSettings.IsDarkMode,
-            cancellationToken);
-
-        await configElementRepository.Upsert(ConfigElementKey.PagesLanguage, uiSettings.Language, cancellationToken);
-
-        return Unit.Default;
-    }
-}

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

@@ -20,7 +20,7 @@ public class UpdateXmltvSettingsHandler(
     {
         int playoutDaysToBuild =
             await configElementRepository
-                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild, cancellationToken)
+                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
                 .IfNoneAsync(2);
 
         if (playoutDaysToBuild < request.XmltvSettings.DaysToBuild)
@@ -29,20 +29,19 @@ public class UpdateXmltvSettingsHandler(
                 $"XMLTV days to build ({request.XmltvSettings.DaysToBuild}) cannot be greater than Playout days to build ({playoutDaysToBuild})");
         }
 
-        return await ApplyUpdate(request.XmltvSettings, cancellationToken);
+        return await ApplyUpdate(request.XmltvSettings);
     }
 
-    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings, CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings)
     {
-        await configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone, cancellationToken);
-        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild, cancellationToken);
-        await configElementRepository.Upsert(ConfigElementKey.XmltvBlockBehavior, xmltvSettings.BlockBehavior, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild);
 
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
 
-        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync(cancellationToken))
+        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync())
         {
-            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber), cancellationToken);
+            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber));
         }
 
         return Unit.Default;

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

@@ -4,5 +4,4 @@ public class PlayoutSettingsViewModel
 {
     public int DaysToBuild { get; set; }
     public bool SkipMissingItems { get; set; }
-    public int ScriptedScheduleTimeoutSeconds { 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.GetConfigElement(request.Key, cancellationToken).MapT(ProjectToViewModel);
+        _configElementRepository.GetConfigElement(request.Key).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -4,49 +4,35 @@ using Serilog.Events;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class GetLoggingSettingsHandler : IRequestHandler<GetLoggingSettings, LoggingSettingsViewModel>
+public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, GeneralSettingsViewModel>
 {
     private readonly IConfigElementRepository _configElementRepository;
 
-    public GetLoggingSettingsHandler(IConfigElementRepository configElementRepository) =>
+    public GetGeneralSettingsHandler(IConfigElementRepository configElementRepository) =>
         _configElementRepository = configElementRepository;
 
-    public async Task<LoggingSettingsViewModel> Handle(GetLoggingSettings request, CancellationToken cancellationToken)
+    public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
     {
         Option<LogEventLevel> maybeDefaultLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel, cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
 
         Option<LogEventLevel> maybeScanningLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelScanning,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScanning);
 
         Option<LogEventLevel> maybeSchedulingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelScheduling,
-                cancellationToken);
-
-        Option<LogEventLevel> maybeSearchingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelSearching,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScheduling);
 
         Option<LogEventLevel> maybeStreamingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelStreaming,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelStreaming);
 
         Option<LogEventLevel> maybeHttpLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelHttp,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelHttp);
 
-        return new LoggingSettingsViewModel
+        return new GeneralSettingsViewModel
         {
             DefaultMinimumLogLevel = await maybeDefaultLevel.IfNoneAsync(LogEventLevel.Information),
             ScanningMinimumLogLevel = await maybeScanningLevel.IfNoneAsync(LogEventLevel.Information),
             SchedulingMinimumLogLevel = await maybeSchedulingLevel.IfNoneAsync(LogEventLevel.Information),
-            SearchingMinimumLogLevel = await maybeSearchingLevel.IfNoneAsync(LogEventLevel.Information),
             StreamingMinimumLogLevel = await maybeStreamingLevel.IfNoneAsync(LogEventLevel.Information),
             HttpMinimumLogLevel = await maybeHttpLevel.IfNoneAsync(LogEventLevel.Information)
         };

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

@@ -11,6 +11,6 @@ public class GetLibraryRefreshIntervalHandler : IRequestHandler<GetLibraryRefres
         _configElementRepository = configElementRepository;
 
     public Task<int> Handle(GetLibraryRefreshInterval request, CancellationToken cancellationToken) =>
-        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval, cancellationToken)
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
             .Map(result => result.IfNone(6));
 }

ErsatzTV.Application/Configuration/Queries/GetLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetMpegTsScripts.cs

@@ -1,5 +0,0 @@
-using ErsatzTV.Core.FFmpeg;
-
-namespace ErsatzTV.Application.Configuration;
-
-public record GetMpegTsScripts : IRequest<List<MpegTsScript>>;

ErsatzTV.Application/Configuration/Queries/GetMpegTsScriptsHandler.cs

@@ -1,14 +0,0 @@
-using ErsatzTV.Core.FFmpeg;
-using ErsatzTV.Core.Interfaces.FFmpeg;
-
-namespace ErsatzTV.Application.Configuration;
-
-public class GetMpegTsScriptsHandler(IMpegTsScriptService mpegTsScriptService)
-    : IRequestHandler<GetMpegTsScripts, List<MpegTsScript>>
-{
-    public async Task<List<MpegTsScript>> Handle(GetMpegTsScripts request, CancellationToken cancellationToken)
-    {
-        await mpegTsScriptService.RefreshScripts();
-        return mpegTsScriptService.GetScripts().OrderBy(x => x.Name).ToList();
-    }
-}

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

@@ -12,23 +12,15 @@ public class GetPlayoutSettingsHandler : IRequestHandler<GetPlayoutSettings, Pla
 
     public async Task<PlayoutSettingsViewModel> Handle(GetPlayoutSettings request, CancellationToken cancellationToken)
     {
-        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(
-            ConfigElementKey.PlayoutDaysToBuild,
-            cancellationToken);
+        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
 
         Option<bool> skipMissingItems =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems, cancellationToken);
-
-        Option<int> scriptedScheduleTimeoutSeconds =
-            await _configElementRepository.GetValue<int>(
-                ConfigElementKey.PlayoutScriptedScheduleTimeoutSeconds,
-                cancellationToken);
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems);
 
         return new PlayoutSettingsViewModel
         {
             DaysToBuild = await daysToBuild.IfNoneAsync(2),
-            SkipMissingItems = await skipMissingItems.IfNoneAsync(false),
-            ScriptedScheduleTimeoutSeconds = await scriptedScheduleTimeoutSeconds.IfNoneAsync(30)
+            SkipMissingItems = await skipMissingItems.IfNoneAsync(false)
         };
     }
 }

ErsatzTV.Application/Configuration/Queries/GetUiSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetUiSettingsHandler.cs

@@ -1,25 +0,0 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-
-namespace ErsatzTV.Application.Configuration;
-
-public class GetUiSettingsHandler(IConfigElementRepository configElementRepository)
-    : IRequestHandler<GetUiSettings, UiSettingsViewModel>
-{
-    public async Task<UiSettingsViewModel> Handle(GetUiSettings request, CancellationToken cancellationToken)
-    {
-        Option<bool> pagesIsDarkMode = await configElementRepository.GetValue<bool>(
-            ConfigElementKey.PagesIsDarkMode,
-            cancellationToken);
-
-        Option<string> pagesLanguage = await configElementRepository.GetValue<string>(
-            ConfigElementKey.PagesLanguage,
-            cancellationToken);
-
-        return new UiSettingsViewModel
-        {
-            IsDarkMode = await pagesIsDarkMode.IfNoneAsync(true),
-            Language = await pagesLanguage.IfNoneAsync("en")
-        };
-    }
-}

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

@@ -8,23 +8,15 @@ public class GetXmltvSettingsHandler(IConfigElementRepository configElementRepos
 {
     public async Task<XmltvSettingsViewModel> Handle(GetXmltvSettings request, CancellationToken cancellationToken)
     {
-        Option<int> daysToBuild = await configElementRepository.GetValue<int>(
-            ConfigElementKey.XmltvDaysToBuild,
-            cancellationToken);
+        Option<int> daysToBuild = await configElementRepository.GetValue<int>(ConfigElementKey.XmltvDaysToBuild);
 
         Option<XmltvTimeZone> maybeTimeZone =
-            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken);
-
-        Option<XmltvBlockBehavior> maybeBlockBehavior =
-            await configElementRepository.GetValue<XmltvBlockBehavior>(
-                ConfigElementKey.XmltvBlockBehavior,
-                cancellationToken);
+            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone);
 
         return new XmltvSettingsViewModel
         {
             DaysToBuild = await daysToBuild.IfNoneAsync(2),
-            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local),
-            BlockBehavior = await maybeBlockBehavior.IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly)
+            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local)
         };
     }
 }

ErsatzTV.Application/Configuration/UiSettingsViewModel.cs

@@ -1,8 +0,0 @@
-namespace ErsatzTV.Application.Configuration;
-
-public class UiSettingsViewModel
-{
-    public bool IsDarkMode { get; set; }
-
-    public string Language { get; set; }
-}

ErsatzTV.Application/Configuration/XmltvBlockBehavior.cs

@@ -1,7 +0,0 @@
-namespace ErsatzTV.Application.Configuration;
-
-public enum XmltvBlockBehavior
-{
-    SplitTimeEvenly = 0,
-    UseActualTimes = 1
-}

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

@@ -4,5 +4,4 @@ public class XmltvSettingsViewModel
 {
     public int DaysToBuild { get; set; }
     public XmltvTimeZone TimeZone { get; set; }
-    public XmltvBlockBehavior BlockBehavior { get; set; }
 }

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

@@ -1,43 +1,34 @@
 using System.Globalization;
+using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Metadata;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Emby;
 
 public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyCollections>,
     IRequestHandler<SynchronizeEmbyCollections, Either<BaseError, Unit>>
 {
-    private readonly IScannerProxyService _scannerProxyService;
-
     public CallEmbyCollectionScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        IScannerProxyService scannerProxyService,
-        IRuntimeInfo runtimeInfo,
-        ILogger<CallEmbyCollectionScannerHandler> logger) : base(
-        dbContextFactory,
-        configElementRepository,
-        runtimeInfo,
-        logger)
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo) : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
     {
-        _scannerProxyService = scannerProxyService;
     }
 
     public async Task<Either<BaseError, Unit>>
         Handle(SynchronizeEmbyCollections request, CancellationToken cancellationToken)
     {
-        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, string> validation = await Validate(request);
         return await validation.Match(
-            parameters => PerformScan(parameters, request, cancellationToken),
+            scanner => PerformScan(scanner, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -49,16 +40,13 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
             });
     }
 
-    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
-        TvContext dbContext,
-        SynchronizeEmbyCollections request,
-        CancellationToken cancellationToken)
+    protected override async Task<DateTimeOffset> GetLastScan(TvContext dbContext, SynchronizeEmbyCollections request)
     {
         DateTime minDateTime = await dbContext.EmbyMediaSources
-            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId, cancellationToken)
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId)
             .Match(l => l.LastCollectionsScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
-        return new Tuple<string, DateTimeOffset>(string.Empty, new DateTimeOffset(minDateTime, TimeSpan.Zero));
+        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
     }
 
     protected override bool ScanIsRequired(
@@ -76,40 +64,20 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
     }
 
     private async Task<Either<BaseError, Unit>> PerformScan(
-        ScanParameters parameters,
+        string scanner,
         SynchronizeEmbyCollections request,
         CancellationToken cancellationToken)
     {
-        Option<Guid> maybeScanId = _scannerProxyService.StartScan(FakeLibraryId.EmbyCollections);
-        foreach (var scanId in maybeScanId)
+        var arguments = new List<string>
         {
-            try
-            {
-                var arguments = new List<string>
-                {
-                    "scan-emby-collections",
-                    request.EmbyMediaSourceId.ToString(CultureInfo.InvariantCulture),
-                    GetBaseUrl(scanId)
-                };
+            "scan-emby-collections", request.EmbyMediaSourceId.ToString(CultureInfo.InvariantCulture)
+        };
 
-                if (request.ForceScan)
-                {
-                    arguments.Add("--force");
-                }
-
-                if (request.DeepScan)
-                {
-                    arguments.Add("--deep");
-                }
-
-                return await base.PerformScan(parameters, arguments, cancellationToken).MapT(_ => Unit.Default);
-            }
-            finally
-            {
-                _scannerProxyService.EndScan(scanId);
-            }
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
         }
 
-        return BaseError.New("Emby collections are already scanning");
+        return await base.PerformScan(scanner, arguments, cancellationToken).MapT(_ => Unit.Default);
     }
 }

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -1,15 +1,13 @@
 using System.Globalization;
+using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Emby;
 
@@ -17,17 +15,14 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
     IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
     IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
 {
-    private readonly IScannerProxyService _scannerProxyService;
-
     public CallEmbyLibraryScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        IScannerProxyService scannerProxyService,
-        IRuntimeInfo runtimeInfo,
-        ILogger<CallEmbyLibraryScannerHandler> logger)
-        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
     {
-        _scannerProxyService = scannerProxyService;
     }
 
     Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>.Handle(
@@ -43,9 +38,9 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, string> validation = await Validate(request);
         return await validation.Match(
-            parameters => PerformScan(parameters, request, cancellationToken),
+            scanner => PerformScan(scanner, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -58,58 +53,37 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
     }
 
     private async Task<Either<BaseError, string>> PerformScan(
-        ScanParameters parameters,
+        string scanner,
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.EmbyLibraryId);
-        foreach (var scanId in maybeScanId)
+        var arguments = new List<string>
         {
-            try
-            {
-                var arguments = new List<string>
-                {
-                    "scan-emby",
-                    request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
-                    GetBaseUrl(scanId)
-                };
+            "scan-emby", request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture)
+        };
 
-                if (request.ForceScan)
-                {
-                    arguments.Add("--force");
-                }
-
-                if (request.DeepScan)
-                {
-                    arguments.Add("--deep");
-                }
-
-                return await base.PerformScan(parameters, arguments, cancellationToken);
-            }
-            finally
-            {
-                _scannerProxyService.EndScan(scanId);
-            }
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
         }
 
-        return BaseError.New($"Library {request.EmbyLibraryId} is already scanning");
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
     }
 
-    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
+    protected override async Task<DateTimeOffset> GetLastScan(
         TvContext dbContext,
-        ISynchronizeEmbyLibraryById request,
-        CancellationToken cancellationToken)
+        ISynchronizeEmbyLibraryById request)
     {
-        Option<EmbyLibrary> maybeLibrary = await dbContext.EmbyLibraries
-            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId, cancellationToken);
+        DateTime minDateTime = await dbContext.EmbyLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId)
+            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
-        DateTime minDateTime = maybeLibrary.Match(
-            l => l.LastScan ?? SystemTime.MinValueUtc,
-            () => SystemTime.MaxValueUtc);
-
-        string libraryName = maybeLibrary.Match(l => l.Name, string.Empty);
-
-        return new Tuple<string, DateTimeOffset>(libraryName, new DateTimeOffset(minDateTime, TimeSpan.Zero));
+        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
     }
 
     protected override bool ScanIsRequired(

ErsatzTV.Application/Emby/Commands/CallEmbyShowScannerHandler.cs

@@ -1,97 +0,0 @@
-using System.Globalization;
-using ErsatzTV.Application.Libraries;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.FFmpeg.Runtime;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.Application.Emby;
-
-public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyShowById>,
-    IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>
-{
-    private readonly IScannerProxyService _scannerProxyService;
-
-    public CallEmbyShowScannerHandler(
-        IDbContextFactory<TvContext> dbContextFactory,
-        IConfigElementRepository configElementRepository,
-        IScannerProxyService scannerProxyService,
-        IRuntimeInfo runtimeInfo,
-        ILogger<CallEmbyShowScannerHandler> logger)
-        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
-    {
-        _scannerProxyService = scannerProxyService;
-    }
-
-    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>.Handle(
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken) => Handle(request, cancellationToken);
-
-    private async Task<Either<BaseError, string>> Handle(
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken)
-    {
-        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
-        return await validation.Match(
-            parameters => PerformScan(parameters, request, cancellationToken),
-            error =>
-            {
-                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
-                {
-                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
-                }
-
-                return Task.FromResult<Either<BaseError, string>>(error.Join());
-            });
-    }
-
-    private async Task<Either<BaseError, string>> PerformScan(
-        ScanParameters parameters,
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken)
-    {
-        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.EmbyLibraryId);
-        foreach (var scanId in maybeScanId)
-        {
-            try
-            {
-                var arguments = new List<string>
-                {
-                    "scan-emby-show",
-                    request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
-                    request.ShowId.ToString(CultureInfo.InvariantCulture),
-                    GetBaseUrl(scanId)
-                };
-
-                if (request.DeepScan)
-                {
-                    arguments.Add("--deep");
-                }
-
-                return await base.PerformScan(parameters, arguments, cancellationToken);
-            }
-            finally
-            {
-                _scannerProxyService.EndScan(scanId);
-            }
-        }
-
-        return BaseError.New($"Library {request.EmbyLibraryId} is already scanning");
-    }
-
-    protected override Task<Tuple<string, DateTimeOffset>> GetLastScan(
-        TvContext dbContext,
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken) =>
-        Task.FromResult(new Tuple<string, DateTimeOffset>(string.Empty, DateTimeOffset.MinValue));
-
-    protected override bool ScanIsRequired(
-        DateTimeOffset lastScan,
-        int libraryRefreshInterval,
-        SynchronizeEmbyShowById request) =>
-        true;
-}

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -3,7 +3,6 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
-using Microsoft.Extensions.Caching.Memory;
 
 namespace ErsatzTV.Application.Emby;
 
@@ -13,19 +12,16 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
     private readonly IEmbyApiClient _embyApiClient;
     private readonly IEmbySecretStore _embySecretStore;
     private readonly IMediaSourceRepository _mediaSourceRepository;
-    private readonly IMemoryCache _memoryCache;
 
     public SaveEmbySecretsHandler(
         IEmbySecretStore embySecretStore,
         IEmbyApiClient embyApiClient,
         IMediaSourceRepository mediaSourceRepository,
-        IMemoryCache memoryCache,
         ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
         _embySecretStore = embySecretStore;
         _embyApiClient = embyApiClient;
         _mediaSourceRepository = mediaSourceRepository;
-        _memoryCache = memoryCache;
         _channel = channel;
     }
 
@@ -51,7 +47,6 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
             parameters.Secrets.Address,
             parameters.ServerInformation.ServerName,
             parameters.ServerInformation.OperatingSystem);
-        _memoryCache.Remove(new GetEmbyConnectionParameters());
         await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
 
         return Unit.Default;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -33,21 +33,18 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
     public Task<Either<BaseError, Unit>> Handle(
         SynchronizeEmbyLibraries request,
         CancellationToken cancellationToken) =>
-        Validate(request, cancellationToken)
-            .MapT(p => SynchronizeLibraries(p, cancellationToken))
+        Validate(request)
+            .MapT(SynchronizeLibraries)
             .Bind(v => v.ToEitherAsync());
 
-    private Task<Validation<BaseError, ConnectionParameters>> Validate(
-        SynchronizeEmbyLibraries request,
-        CancellationToken cancellationToken) =>
-        MediaSourceMustExist(request, cancellationToken)
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
+        MediaSourceMustExist(request)
             .BindT(MediaSourceMustHaveActiveConnection)
             .BindT(MediaSourceMustHaveApiKey);
 
     private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
-        SynchronizeEmbyLibraries request,
-        CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken)
+        SynchronizeEmbyLibraries request) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
             .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
 
     private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
@@ -68,9 +65,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
             .ToValidation<BaseError>("Emby media source requires an api key");
     }
 
-    private async Task<Unit> SynchronizeLibraries(
-        ConnectionParameters connectionParameters,
-        CancellationToken cancellationToken)
+    private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
     {
         Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
             connectionParameters.ActiveConnection.Address,
@@ -96,8 +91,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
                 connectionParameters.EmbyMediaSource.Id,
                 toAdd,
                 toRemove,
-                toUpdate,
-                cancellationToken);
+                toUpdate);
             if (ids.Count != 0)
             {
                 await _searchIndex.RemoveItems(ids);

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -23,7 +23,7 @@ public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmb
         SynchronizeEmbyMediaSources request,
         CancellationToken cancellationToken)
     {
-        List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby(cancellationToken);
+        List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
         foreach (EmbyMediaSource mediaSource in mediaSources)
         {
             await _scannerWorkerChannel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyShowById.cs

@@ -1,6 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Emby;
-
-public record SynchronizeEmbyShowById(int EmbyLibraryId, int ShowId, bool DeepScan)
-    : IRequest<Either<BaseError, string>>, IScannerBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

@@ -23,7 +23,7 @@ public class
         UpdateEmbyLibraryPreferences request,
         CancellationToken cancellationToken)
     {
-        var toDisable = request.Preferences.Filter(p => !p.ShouldSyncItems).Map(p => p.Id).ToList();
+        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
         List<int> ids = await _mediaSourceRepository.DisableEmbyLibrarySync(toDisable);
         await _searchIndex.RemoveItems(ids);
         _searchIndex.Commit();

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -15,7 +15,7 @@ public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathR
     public Task<Either<BaseError, Unit>> Handle(
         UpdateEmbyPathReplacements request,
         CancellationToken cancellationToken) =>
-        Validate(request, cancellationToken)
+        Validate(request)
             .MapT(pms => MergePathReplacements(request, pms))
             .Bind(v => v.ToEitherAsync());
 
@@ -37,12 +37,13 @@ public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathR
     private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
         new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
 
-    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request, CancellationToken cancellationToken) =>
-        EmbyMediaSourceMustExist(request, cancellationToken);
+    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
+        EmbyMediaSourceMustExist(request);
 
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-        UpdateEmbyPathReplacements request, CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken)
-            .Map(v => v.ToValidation<BaseError>(
-                $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+        UpdateEmbyPathReplacements request) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Emby media source {request.EmbyMediaSourceId} does not exist."));
 }

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

@@ -13,5 +13,5 @@ public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSour
     public Task<List<EmbyMediaSourceViewModel>> Handle(
         GetAllEmbyMediaSources request,
         CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetAllEmby(cancellationToken).Map(list => list.Map(ProjectToViewModel).ToList());
+        _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
 }

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -34,7 +34,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
         }
 
         Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
-            await Validate(cancellationToken)
+            await Validate()
                 .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address, cp.ApiKey))
                 .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
 
@@ -47,16 +47,16 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
             error => error);
     }
 
-    private Task<Validation<BaseError, ConnectionParameters>> Validate(CancellationToken cancellationToken) =>
-        EmbyMediaSourceMustExist(cancellationToken)
+    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+        EmbyMediaSourceMustExist()
             .BindT(MediaSourceMustHaveActiveConnection)
             .BindT(MediaSourceMustHaveApiKey);
 
-    private Task<Validation<BaseError, EmbyMediaSource>>
-        EmbyMediaSourceMustExist(CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetAllEmby(cancellationToken).Map(list => list.HeadOrNone())
-            .Map(v => v.ToValidation<BaseError>(
-                "Emby media source does not exist."));
+    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+        _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    "Emby media source does not exist."));
 
     private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
         EmbyMediaSource embyMediaSource)

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs

@@ -14,5 +14,5 @@ public class
     public Task<Option<EmbyMediaSourceViewModel>> Handle(
         GetEmbyMediaSourceById request,
         CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken).MapT(ProjectToViewModel);
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,30 +1,33 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net10.0</TargetFramework>
-        <NoWarn>VSTHRD200,CA1873</NoWarn>
+        <TargetFramework>net8.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
         <AnalysisLevel>latest-Recommended</AnalysisLevel>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-        <Configurations>Debug;Release;Debug No Sync</Configurations>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="MediatR" Version="[12.5.0]" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
-        <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
-        <PackageReference Include="WebMarkupMin.Core" Version="2.20.1" />
-        <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
+      <PackageReference Include="Bugsnag" Version="4.0.0" />
+      <PackageReference Include="CliWrap" Version="3.8.2" />
+      <PackageReference Include="Humanizer.Core" Version="2.14.1" />
+      <PackageReference Include="MediatR" Version="12.5.0" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.4" />
+      <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.1" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.13.61">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
+      <PackageReference Include="WebMarkupMin.Core" Version="2.17.0" />
+      <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
-        <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />
+      <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
+      <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />
     </ItemGroup>
 
 </Project>