update changelog for release v0.3.1-alpha [no ci]

.config/dotnet-tools.json

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

.editorconfig

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

.gitattributes

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

.github/dependabot.yml

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

.github/workflows/artifacts.yml

@@ -1,246 +0,0 @@
-name: Build Artifacts
-on:
-  workflow_call:
-    inputs:
-      release_tag:
-        description: 'Release tag'
-        required: true
-        type: string
-      release_version:
-        description: 'Release version number (e.g. v0.3.7-alpha)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-    secrets:
-      apple_developer_certificate_p12_base64:
-        required: true
-      apple_developer_certificate_password:
-        required: true
-      ac_username:
-        required: true
-      ac_password:
-        required: true
-      gh_token:
-        required: true
-jobs:
-  build_and_upload_mac:
-    name: Mac Build & Upload
-    runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    strategy:
-      matrix:
-        include:
-          - os: macos-14
-            kind: macOS
-            target: osx-x64
-          - os: macos-14
-            kind: macOS
-            target: osx-arm64
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 9.0.203
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target}}"
-
-      - name: Import Code-Signing Certificates
-        uses: Apple-Actions/import-codesign-certs@v2
-        with:
-          p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
-          p12-password: ${{ secrets.apple_developer_certificate_password }}
-
-      - name: Calculate Release Name
-        shell: bash
-        run: |
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-      - name: Build
-        shell: bash
-        run: |
-          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Bundle
-        shell: bash
-        run: |
-          brew install coreutils
-          plutil -replace CFBundleShortVersionString -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          plutil -replace CFBundleVersion -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          scripts/macOS/bundle.sh
-
-      - name: Sign
-        shell: bash
-        run: scripts/macOS/sign.sh
-
-      - name: Create DMG
-        shell: bash
-        run: |
-          brew install create-dmg
-          create-dmg \
-            --volname "ErsatzTV" \
-            --volicon "artwork/ErsatzTV.icns" \
-            --window-pos 200 120 \
-            --window-size 800 400 \
-            --icon-size 100 \
-            --icon "ErsatzTV.app" 200 190 \
-            --hide-extension "ErsatzTV.app" \
-            --app-drop-link 600 185 \
-            --skip-jenkins \
-            --no-internet-enable \
-            "ErsatzTV.dmg" \
-            "ErsatzTV.app/"
-
-      - name: Notarize
-        shell: bash
-        run: |
-          xcrun notarytool submit ErsatzTV.dmg --apple-id "${{ secrets.ac_username }}" --password "${{ secrets.ac_password }}" --team-id 32MB98Q32R --wait
-          xcrun stapler staple ErsatzTV.dmg
-
-      - name: Cleanup
-        shell: bash
-        run: |
-          mv ErsatzTV.dmg "${{ env.RELEASE_NAME }}.dmg"
-          rm -r publish
-          rm -r ErsatzTV.app
-
-      - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
-        if: ${{ inputs.release_tag == 'develop' }}
-        with:
-          token: ${{ secrets.gh_token }}
-          tag: ${{ inputs.release_tag }}
-          fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.dmg
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.dmg
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}
-  build_and_upload:
-    name: Build & Upload
-    runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-musl-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-arm
-          - os: ubuntu-24.04-arm
-            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 .NET Core
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 9.0.203
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target }}"
-
-      - uses: suisei-cn/actions-download-file@v1.3.0
-        if: ${{ matrix.kind == 'windows' }}
-        id: downloadffmpeg
-        name: Download ffmpeg
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/7.1.1/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip"
-          target: ffmpeg/
-
-      - name: Build
-        shell: bash
-        run: |
-          # Define some variables for things we need
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-          # Build everything
-          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          mkdir "$release_name"
-          mv scanner/* "$release_name/"
-          mv main/* "$release_name/"
-
-          # Build Windows launcher
-          if [ "${{ matrix.kind }}" == "windows" ]; then
-            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"
-
-      - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
-        if: ${{ inputs.release_tag == 'develop' }}
-        with:
-          token: ${{ secrets.gh_token }}
-          tag: ${{ inputs.release_tag }}
-          fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.zip
-            *${{ matrix.target }}.tar.gz
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.zip
-            ${{ env.RELEASE_NAME }}.tar.gz
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

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

.github/workflows/docker.yml

@@ -1,131 +0,0 @@
-name: Build & Publish to Docker Hub
-on:
-  workflow_call:
-    inputs:
-      base_version:
-        description: 'Base version (latest or develop)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-      tag_version:
-        description: 'Docker tag version (e.g. v0.3.7)'
-        required: true
-        type: string
-    secrets:
-      docker_hub_username:
-        required: true
-      docker_hub_access_token:
-        required: true
-jobs:
-  build_and_push:
-    name: Build & Publish
-    runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    strategy:
-      matrix:
-        include:
-          - name: amd64
-            os: ubuntu-latest
-            path: ''
-            suffix: '-amd64'
-            qemu: false
-            platform: 'linux/amd64'
-          - name: arm32v7
-            os: ubuntu-latest
-            path: 'arm32v7/'
-            suffix: '-arm'
-            qemu: true
-            platform: 'linux/arm/v7'
-          - name: arm64
-            os: ubuntu-24.04-arm
-            path: 'arm64/'
-            suffix: '-arm64'
-            qemu: true
-            platform: 'linux/arm64'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up QEMU
-        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
-        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: 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 }}
-          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 }}
-
-  merge_manifests:
-    name: Merge Manifests
-    runs-on: ubuntu-latest
-    needs: build_and_push
-    steps:
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.docker_hub_username }}
-          password: ${{ secrets.docker_hub_access_token }}
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create and push manifests
-        run: |
-          docker manifest create jasongdove/ersatztv:${{ inputs.base_version }} \
-            jasongdove/ersatztv:${{ inputs.base_version }}-amd64 \
-            jasongdove/ersatztv:${{ inputs.base_version }}-arm64 \
-            jasongdove/ersatztv:${{ inputs.base_version }}-arm
-          docker manifest push jasongdove/ersatztv:${{ inputs.base_version }}
-          docker manifest create jasongdove/ersatztv:${{ inputs.tag_version }} \
-            jasongdove/ersatztv:${{ inputs.tag_version }}-amd64 \
-            jasongdove/ersatztv:${{ inputs.tag_version }}-arm64 \
-            jasongdove/ersatztv:${{ inputs.tag_version }}-arm
-          docker manifest push jasongdove/ersatztv:${{ inputs.tag_version }}
-          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }} \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}-amd64 \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}-arm64 \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}-arm
-          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}
-          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }} \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}-amd64 \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}-arm64 \
-            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}-arm
-          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}

.github/workflows/docs.yml

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

.github/workflows/issue-stale.yml

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

.github/workflows/pr.yml

@@ -1,98 +0,0 @@
-name: Pull Request
-on:
-  pull_request:
-jobs:
-  build_and_test_windows:
-    runs-on: windows-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 9.0.203
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Prep project file
-        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --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
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 9.0.203
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
-
-      - name: Prep project file
-        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && 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
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 9.0.203
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Prep project file
-        run: sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal

.github/workflows/release.yml

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

.gitignore

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

.gitmodules

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

Directory.Build.props

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

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

@@ -1,115 +0,0 @@
-#![windows_subsystem = "windows"]
-
-use special_folder::SpecialFolder;
-use std::env;
-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 ui_port = env::var("ETV_UI_PORT")
-            .ok()
-            .and_then(|val| val.parse::<u16>().ok())
-            .unwrap_or(8409);
-
-        let _ = Command::new("cmd")
-            .creation_flags(CREATE_NO_WINDOW)
-            .arg("/C")
-            .arg("start")
-            .arg(format!("http://localhost:{}", ui_port))
-            .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/.editorconfig

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

ErsatzTV.Application/Artists/ArtistViewModel.cs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

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/GetArtwork.cs

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

ErsatzTV.Application/Artworks/Queries/GetArtworkHandler.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelData.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelList.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

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

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,75 +1,29 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core.Api.Channels;
+using System.Linq;
 using ErsatzTV.Core.Domain;
+using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels;
-
-internal static class Mapper
+namespace ErsatzTV.Application.Channels
 {
-    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-        new(
-            channel.Id,
-            channel.Number,
-            channel.Name,
-            channel.Group,
-            channel.Categories,
-            channel.FFmpegProfileId,
-            GetLogo(channel),
-            channel.StreamSelectorMode,
-            channel.StreamSelector,
-            channel.PreferredAudioLanguageCode,
-            channel.PreferredAudioTitle,
-            channel.ProgressMode,
-            channel.StreamingMode,
-            channel.WatermarkId,
-            channel.FallbackFillerId,
-            channel.Playouts?.Count ?? 0,
-            channel.PreferredSubtitleLanguageCode,
-            channel.SubtitleMode,
-            channel.MusicVideoCreditsMode,
-            channel.MusicVideoCreditsTemplate,
-            channel.SongVideoMode,
-            channel.ActiveMode);
-
-    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
-        new(
-            channel.Id,
-            channel.Number,
-            channel.Name,
-            channel.FFmpegProfile.Name,
-            channel.PreferredAudioLanguageCode,
-            GetStreamingMode(channel));
-
-    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
-        new(resolution.Height, resolution.Width);
-
-    internal static ResolutionAndBitrateViewModel ProjectToViewModel(Resolution resolution, int bitrate) =>
-        new(resolution.Height, resolution.Width, bitrate);
-
-    private static ArtworkContentTypeModel GetLogo(Channel channel)
+    internal static class Mapper
     {
-        Option<Artwork> maybeArtwork = channel.Artwork
-            .Where(a => a.ArtworkKind == ArtworkKind.Logo)
-            .HeadOrNone();
+        internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
+            new(
+                channel.Id,
+                channel.Number,
+                channel.Name,
+                channel.FFmpegProfileId,
+                GetLogo(channel),
+                channel.PreferredLanguageCode,
+                channel.StreamingMode,
+                channel.WatermarkId,
+                channel.FallbackFillerId);
 
-        foreach (Artwork artwork in maybeArtwork)
-        {
-            return artwork.IsExternalUrl()
-                ? new ArtworkContentTypeModel(artwork.Path, string.Empty)
-                : new ArtworkContentTypeModel($"iptv/logos/{artwork.Path}", artwork.OriginalContentType);
-        }
+        private static string GetLogo(Channel channel) =>
+            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+                .Match(a => a.Path, string.Empty);
 
-        return ArtworkContentTypeModel.None;
+        private static string GetWatermark(Channel channel) =>
+            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
+                .Match(a => a.Path, string.Empty);
     }
-
-    private static string GetStreamingMode(Channel channel) =>
-        channel.StreamingMode switch
-        {
-            StreamingMode.TransportStream => "MPEG-TS (Legacy)",
-            StreamingMode.TransportStreamHybrid => "MPEG-TS",
-            StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
-            StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
-            StreamingMode.HttpLiveStreamingSegmenterV2 => "HLS Segmenter V2",
-            _ => throw new ArgumentOutOfRangeException(nameof(channel))
-        };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrateHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectors.cs

@@ -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/ResolutionAndBitrateViewModel.cs

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

ErsatzTV.Application/Channels/ResolutionViewModel.cs

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

ErsatzTV.Application/Channels/XmlTemplateContext.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

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

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

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

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

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

ErsatzTV.Application/Configuration/LoggingSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetLoggingSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

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

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

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