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

Co-authored-by: Jason <jason@mbp-touch.local>

.config/dotnet-tools.json

@@ -3,16 +3,10 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2020.3.2",
+      "version": "2023.2.0",
       "commands": [
         "jb"
       ]
-    },
-    "swashbuckle.aspnetcore.cli": {
-      "version": "5.6.2",
-      "commands": [
-        "swagger"
-      ]
     }
   }
 }

.editorconfig

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

.github/dependabot.yml

@@ -0,0 +1,26 @@
+version: 2
+updates:
+  - package-ecosystem: nuget
+    directory: "/"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker/nvidia"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove
+  - package-ecosystem: docker
+    directory: "/docker/vaapi"
+    schedule:
+      interval: daily
+    assignees:
+      - jasongdove

.github/workflows/artifacts.yml

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

.github/workflows/ci.yml

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

.github/workflows/docker.yml

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

.github/workflows/pr.yml

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

.github/workflows/release.yml

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

.github/workflows/vue-lint.yml

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

.gitignore

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

.gitmodules

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

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

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

ErsatzTV.Application/.editorconfig

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

ErsatzTV.Application/Artists/ArtistViewModel.cs

@@ -0,0 +1,14 @@
+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);

ErsatzTV.Application/Artists/Mapper.cs

@@ -0,0 +1,40 @@
+using System.Globalization;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artists;
+
+internal static class Mapper
+{
+    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 List<CultureInfo> LanguagesForArtist(List<string> languages)
+    {
+        CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+        return languages
+            .Distinct()
+            .Map(
+                lang => allCultures.Filter(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+            .Sequence()
+            .Flatten()
+            .ToList();
+    }
+}

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Application.MediaItems;
+
+namespace ErsatzTV.Application.Artists;
+
+public record GetAllArtists : IRequest<List<NamedMediaItemViewModel>>;

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -0,0 +1,41 @@
+using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaItems.Mapper;
+
+namespace ErsatzTV.Application.Artists;
+
+public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllArtistsHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+
+    public async Task<List<NamedMediaItemViewModel>> Handle(
+        GetAllArtists request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<Artist> allArtists = await dbContext.Artists
+            .AsNoTracking()
+            .Include(a => a.ArtistMetadata)
+            .ToListAsync(cancellationToken);
+
+        return allArtists.Bind(a => ProjectArtist(a)).ToList();
+    }
+
+    private static Option<NamedMediaItemViewModel> ProjectArtist(Artist a)
+    {
+        foreach (ArtistMetadata metadata in a.ArtistMetadata.HeadOrNone())
+        {
+            if (!string.IsNullOrWhiteSpace(metadata.Title))
+            {
+                return ProjectToViewModel(a);
+            }
+        }
+
+        return None;
+    }
+}

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Artists;
+
+public record GetArtistById(int ArtistId) : IRequest<Option<ArtistViewModel>>;

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

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

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

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelData.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -0,0 +1,525 @@
+using System.Globalization;
+using System.Xml;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Jellyfin;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.IO;
+
+namespace ErsatzTV.Application.Channels;
+
+public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<RefreshChannelDataHandler> _logger;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public RefreshChannelDataHandler(
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILocalFileSystem localFileSystem,
+        ILogger<RefreshChannelDataHandler> logger)
+    {
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _dbContextFactory = dbContextFactory;
+        _localFileSystem = localFileSystem;
+        _logger = logger;
+    }
+
+    public async Task Handle(RefreshChannelData request, CancellationToken cancellationToken)
+    {
+        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<PlayoutItem> sorted = await dbContext.Playouts
+            .AsNoTracking()
+            .Filter(pi => pi.Channel.Number == request.ChannelNumber)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(em => em.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Collect(p => p.Items).OrderBy(pi => pi.Start).ToList());
+
+        using MemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+        await using var xml = XmlWriter.Create(
+            ms,
+            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+        // skip all filler that isn't pre-roll
+        var i = 0;
+        while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None &&
+               sorted[i].FillerKind != FillerKind.PreRoll)
+        {
+            i++;
+        }
+
+        while (i < sorted.Count)
+        {
+            PlayoutItem startItem = sorted[i];
+            int j = i;
+            while (sorted[j].FillerKind != FillerKind.None && j + 1 < sorted.Count)
+            {
+                j++;
+            }
+
+            PlayoutItem displayItem = sorted[j];
+            bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
+
+            int finishIndex = j;
+            while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
+                                                      || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
+                                                          or FillerKind.Tail or FillerKind.Fallback))
+            {
+                finishIndex++;
+            }
+
+            int customShowId = -1;
+            if (displayItem.MediaItem is Episode ep)
+            {
+                customShowId = ep.Season.ShowId;
+            }
+
+            bool isSameCustomShow = hasCustomTitle;
+            for (int x = j; x <= finishIndex; x++)
+            {
+                isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
+                                   customShowId == e.Season.ShowId;
+            }
+
+            PlayoutItem finishItem = sorted[finishIndex];
+            i = finishIndex;
+
+            string start = startItem.StartOffset.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                .Replace(":", string.Empty);
+            string stop = displayItem.GuideFinishOffset.HasValue
+                ? displayItem.GuideFinishOffset.Value.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty)
+                : finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty);
+
+            string title = GetTitle(displayItem);
+            string subtitle = GetSubtitle(displayItem);
+            string description = GetDescription(displayItem);
+            Option<ContentRating> contentRating = GetContentRating(displayItem);
+
+            await xml.WriteStartElementAsync(null, "programme", null);
+            await xml.WriteAttributeStringAsync(null, "start", null, start);
+            await xml.WriteAttributeStringAsync(null, "stop", null, stop);
+            await xml.WriteAttributeStringAsync(null, "channel", null, $"{request.ChannelNumber}.etv");
+
+            await xml.WriteStartElementAsync(null, "title", null);
+            await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+            await xml.WriteStringAsync(title);
+            await xml.WriteEndElementAsync(); // title
+
+            if (!string.IsNullOrWhiteSpace(subtitle))
+            {
+                await xml.WriteStartElementAsync(null, "sub-title", null);
+                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                await xml.WriteStringAsync(subtitle);
+                await xml.WriteEndElementAsync(); // subtitle
+            }
+
+            if (!isSameCustomShow)
+            {
+                if (!string.IsNullOrWhiteSpace(description))
+                {
+                    await xml.WriteStartElementAsync(null, "desc", null);
+                    await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                    await xml.WriteStringAsync(description);
+                    await xml.WriteEndElementAsync(); // desc
+                }
+            }
+
+            if (!hasCustomTitle && displayItem.MediaItem is Movie movie)
+            {
+                foreach (MovieMetadata metadata in movie.MovieMetadata.HeadOrNone())
+                {
+                    if (metadata.Year.HasValue)
+                    {
+                        await xml.WriteStartElementAsync(null, "date", null);
+                        await xml.WriteStringAsync(metadata.Year.Value.ToString(CultureInfo.InvariantCulture));
+                        await xml.WriteEndElementAsync(); // date
+                    }
+
+                    await xml.WriteStartElementAsync(null, "category", null);
+                    await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                    await xml.WriteStringAsync("Movie");
+                    await xml.WriteEndElementAsync(); // category
+
+                    foreach (Genre genre in Optional(metadata.Genres).Flatten().OrderBy(g => g.Name))
+                    {
+                        await xml.WriteStartElementAsync(null, "category", null);
+                        await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                        await xml.WriteStringAsync(genre.Name);
+                        await xml.WriteEndElementAsync(); // category
+                    }
+
+                    string poster = Optional(metadata.Artwork).Flatten()
+                        .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+                        .HeadOrNone()
+                        .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
+
+                    if (!string.IsNullOrWhiteSpace(poster))
+                    {
+                        await xml.WriteStartElementAsync(null, "icon", null);
+                        await xml.WriteAttributeStringAsync(null, "src", null, poster);
+                        await xml.WriteEndElementAsync(); // icon
+                    }
+                }
+            }
+
+            if (!hasCustomTitle && displayItem.MediaItem is MusicVideo musicVideo)
+            {
+                foreach (MusicVideoMetadata metadata in musicVideo.MusicVideoMetadata.HeadOrNone())
+                {
+                    if (metadata.Year.HasValue)
+                    {
+                        await xml.WriteStartElementAsync(null, "date", null);
+                        await xml.WriteStringAsync(metadata.Year.Value.ToString(CultureInfo.InvariantCulture));
+                        await xml.WriteEndElementAsync(); // date
+                    }
+
+                    await xml.WriteStartElementAsync(null, "category", null);
+                    await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                    await xml.WriteStringAsync("Music");
+                    await xml.WriteEndElementAsync(); // category
+
+                    // music video genres
+                    foreach (Genre genre in Optional(metadata.Genres).Flatten().OrderBy(g => g.Name))
+                    {
+                        await xml.WriteStartElementAsync(null, "category", null);
+                        await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                        await xml.WriteStringAsync(genre.Name);
+                        await xml.WriteEndElementAsync(); // category
+                    }
+
+                    // artist genres
+                    Option<ArtistMetadata> maybeMetadata =
+                        Optional(musicVideo.Artist?.ArtistMetadata.HeadOrNone()).Flatten();
+                    foreach (ArtistMetadata artistMetadata in maybeMetadata)
+                    {
+                        foreach (Genre genre in Optional(artistMetadata.Genres).Flatten().OrderBy(g => g.Name))
+                        {
+                            await xml.WriteStartElementAsync(null, "category", null);
+                            await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                            await xml.WriteStringAsync(genre.Name);
+                            await xml.WriteEndElementAsync(); // category
+                        }
+                    }
+
+                    string artworkPath = GetPrioritizedArtworkPath(metadata);
+                    if (!string.IsNullOrWhiteSpace(artworkPath))
+                    {
+                        await xml.WriteStartElementAsync(null, "icon", null);
+                        await xml.WriteAttributeStringAsync(null, "src", null, artworkPath);
+                        await xml.WriteEndElementAsync(); // icon
+                    }
+                }
+            }
+
+            if (!hasCustomTitle && displayItem.MediaItem is Song song)
+            {
+                await xml.WriteStartElementAsync(null, "category", null);
+                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                await xml.WriteStringAsync("Music");
+                await xml.WriteEndElementAsync(); // category
+
+                foreach (SongMetadata metadata in song.SongMetadata.HeadOrNone())
+                {
+                    string artworkPath = GetPrioritizedArtworkPath(metadata);
+                    if (!string.IsNullOrWhiteSpace(artworkPath))
+                    {
+                        await xml.WriteStartElementAsync(null, "icon", null);
+                        await xml.WriteAttributeStringAsync(null, "src", null, artworkPath);
+                        await xml.WriteEndElementAsync(); // icon
+                    }
+                }
+            }
+
+            if (displayItem.MediaItem is Episode episode && (!hasCustomTitle || isSameCustomShow))
+            {
+                Option<ShowMetadata> maybeMetadata =
+                    Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();
+                foreach (ShowMetadata metadata in maybeMetadata)
+                {
+                    await xml.WriteStartElementAsync(null, "category", null);
+                    await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                    await xml.WriteStringAsync("Series");
+                    await xml.WriteEndElementAsync(); // category
+
+                    foreach (Genre genre in Optional(metadata.Genres).Flatten().OrderBy(g => g.Name))
+                    {
+                        await xml.WriteStartElementAsync(null, "category", null);
+                        await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                        await xml.WriteStringAsync(genre.Name);
+                        await xml.WriteEndElementAsync(); // category
+                    }
+
+                    string artworkPath = GetPrioritizedArtworkPath(metadata);
+                    if (!string.IsNullOrWhiteSpace(artworkPath))
+                    {
+                        await xml.WriteStartElementAsync(null, "icon", null);
+                        await xml.WriteAttributeStringAsync(null, "src", null, artworkPath);
+                        await xml.WriteEndElementAsync(); // icon
+                    }
+                }
+
+                if (!isSameCustomShow)
+                {
+                    int s = await Optional(episode.Season?.SeasonNumber).IfNoneAsync(-1);
+                    // TODO: multi-episode?
+                    int e = episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, -1);
+                    if (s >= 0 && e > 0)
+                    {
+                        await xml.WriteStartElementAsync(null, "episode-num", null);
+                        await xml.WriteAttributeStringAsync(null, "system", null, "onscreen");
+                        await xml.WriteStringAsync($"S{s:00}E{e:00}");
+                        await xml.WriteEndElementAsync(); // episode-num
+
+                        await xml.WriteStartElementAsync(null, "episode-num", null);
+                        await xml.WriteAttributeStringAsync(null, "system", null, "xmltv_ns");
+                        await xml.WriteStringAsync($"{s - 1}.{e - 1}.0/1");
+                        await xml.WriteEndElementAsync(); // episode-num
+                    }
+                }
+            }
+
+            await xml.WriteStartElementAsync(null, "previously-shown", null);
+            await xml.WriteEndElementAsync(); // previously-shown
+
+            foreach (ContentRating rating in contentRating)
+            {
+                await xml.WriteStartElementAsync(null, "rating", null);
+                foreach (string system in rating.System)
+                {
+                    await xml.WriteAttributeStringAsync(null, "system", null, system);
+                }
+
+                await xml.WriteStartElementAsync(null, "value", null);
+                await xml.WriteStringAsync(rating.Value);
+                await xml.WriteEndElementAsync(); // value
+                await xml.WriteEndElementAsync(); // rating
+            }
+
+            await xml.WriteEndElementAsync(); // programme
+
+            i++;
+        }
+
+        await xml.FlushAsync();
+
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
+        File.Move(tempFile, targetFile, true);
+    }
+
+    private static string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
+    {
+        string artworkPath = artwork.Path;
+
+        int height = artworkKind switch
+        {
+            ArtworkKind.Thumbnail => 220,
+            _ => 440
+        };
+
+        if (artworkPath.StartsWith("jellyfin://", StringComparison.OrdinalIgnoreCase))
+        {
+            artworkPath = JellyfinUrl.PlaceholderProxyForArtwork(artworkPath, artworkKind, height);
+        }
+        else if (artworkPath.StartsWith("emby://", StringComparison.OrdinalIgnoreCase))
+        {
+            artworkPath = EmbyUrl.PlaceholderProxyForArtwork(artworkPath, artworkKind, height);
+        }
+        else
+        {
+            string artworkFolder = artworkKind switch
+            {
+                ArtworkKind.Thumbnail => "thumbnails",
+                _ => "posters"
+            };
+
+            artworkPath = $"{{RequestBase}}/iptv/artwork/{artworkFolder}/{artwork.Path}.jpg{{AccessTokenUri}}";
+        }
+
+        return artworkPath;
+    }
+
+    private static string GetTitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return playoutItem.CustomTitle;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
+                .IfNone("[unknown movie]"),
+            Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
+                .IfNone("[unknown show]"),
+            MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
+                .IfNone("[unknown artist]"),
+            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown video]"),
+            Song s => s.SongMetadata.HeadOrNone().Map(sm => sm.Artist ?? string.Empty)
+                .IfNone("[unknown artist]"),
+            _ => "[unknown]"
+        };
+    }
+
+    private static string GetSubtitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return string.Empty;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.Title ?? string.Empty,
+                () => string.Empty),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            Song s => s.SongMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            _ => string.Empty
+        };
+    }
+
+    private static string GetDescription(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return string.Empty;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
+            Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
+                .IfNone(string.Empty),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => mvm.Plot ?? string.Empty)
+                .IfNone(string.Empty),
+            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(ovm => ovm.Plot ?? string.Empty)
+                .IfNone(string.Empty),
+            _ => string.Empty
+        };
+    }
+
+    private Option<ContentRating> GetContentRating(PlayoutItem playoutItem)
+    {
+        try
+        {
+            return playoutItem.MediaItem switch
+            {
+                Movie m => m.MovieMetadata
+                    .HeadOrNone()
+                    .Match(mm => ParseContentRating(mm.ContentRating, "MPAA"), () => None),
+                Episode e => e.Season.Show.ShowMetadata
+                    .HeadOrNone()
+                    .Match(sm => ParseContentRating(sm.ContentRating, "VCHIP"), () => None),
+                _ => None
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to get content rating for playout item {Item}", GetTitle(playoutItem));
+            return None;
+        }
+    }
+
+    private static Option<ContentRating> ParseContentRating(string contentRating, string system)
+    {
+        Option<string> maybeFirst = (contentRating ?? string.Empty).Split('/').HeadOrNone();
+        return maybeFirst.Map(
+            first =>
+            {
+                string[] split = first.Split(':');
+                if (split.Length == 2)
+                {
+                    return split[0].ToLowerInvariant() == "us"
+                        ? new ContentRating(system, split[1].ToUpperInvariant())
+                        : new ContentRating(None, split[1].ToUpperInvariant());
+                }
+
+                return string.IsNullOrWhiteSpace(first)
+                    ? Option<ContentRating>.None
+                    : new ContentRating(None, first);
+            }).Flatten();
+    }
+
+    private static string GetPrioritizedArtworkPath(Metadata metadata)
+    {
+        Option<string> maybeArtwork = Optional(metadata.Artwork).Flatten()
+            .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+            .HeadOrNone()
+            .Map(a => GetArtworkUrl(a, ArtworkKind.Poster));
+
+        if (maybeArtwork.IsNone)
+        {
+            maybeArtwork = Optional(metadata.Artwork).Flatten()
+                .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
+                .HeadOrNone()
+                .Map(a => GetArtworkUrl(a, ArtworkKind.Thumbnail));
+        }
+
+        return maybeArtwork.IfNone(string.Empty);
+    }
+
+    private sealed record ContentRating(Option<string> System, string Value);
+}

ErsatzTV.Application/Channels/Commands/RefreshChannelList.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -0,0 +1,116 @@
+using System.Data.Common;
+using System.Xml;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IO;
+
+namespace ErsatzTV.Application.Channels;
+
+public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public RefreshChannelListHandler(
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILocalFileSystem localFileSystem)
+    {
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _dbContextFactory = dbContextFactory;
+        _localFileSystem = localFileSystem;
+    }
+
+    public async Task Handle(RefreshChannelList request, CancellationToken cancellationToken)
+    {
+        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        using MemoryStream 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))
+        {
+            await xml.WriteStartElementAsync(null, "channel", null);
+            await xml.WriteAttributeStringAsync(null, "id", null, $"{channel.Number}.etv");
+
+            await xml.WriteStartElementAsync(null, "display-name", null);
+            await xml.WriteStringAsync($"{channel.Number} {channel.Name}");
+            await xml.WriteEndElementAsync(); // display-name (number and name)
+
+            await xml.WriteStartElementAsync(null, "display-name", null);
+            await xml.WriteStringAsync(channel.Number);
+            await xml.WriteEndElementAsync(); // display-name (number)
+
+            await xml.WriteStartElementAsync(null, "display-name", null);
+            await xml.WriteStringAsync(channel.Name);
+            await xml.WriteEndElementAsync(); // display-name (name)
+
+            foreach (string category in GetCategories(channel.Categories))
+            {
+                await xml.WriteStartElementAsync(null, "category", null);
+                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
+                await xml.WriteStringAsync(category);
+                await xml.WriteEndElementAsync(); // category
+            }
+
+            await xml.WriteStartElementAsync(null, "icon", null);
+            await xml.WriteAttributeStringAsync(null, "src", null, GetIconUrl(channel));
+            await xml.WriteEndElementAsync(); // icon
+
+            await xml.WriteEndElementAsync(); // channel
+        }
+
+        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)
+                               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();
+
+    private static string GetIconUrl(ChannelResult channel) =>
+        string.IsNullOrWhiteSpace(channel.ArtworkPath)
+            ? "{RequestBase}/iptv/images/ersatztv-500.png{AccessTokenUri}"
+            : $"{{RequestBase}}/iptv/logos/{channel.ArtworkPath}.jpg{{AccessTokenUri}}";
+
+    // ReSharper disable once ClassNeverInstantiated.Local
+    private sealed record ChannelResult(string Number, string Name, string Categories, string ArtworkPath);
+}

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

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

ErsatzTV.Application/Channels/Mapper.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,20 +1,72 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
+using System.Text;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IO;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
 {
-    public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public GetChannelGuideHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        ILocalFileSystem localFileSystem)
     {
-        private readonly IChannelRepository _channelRepository;
+        _dbContextFactory = dbContextFactory;
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _localFileSystem = localFileSystem;
+    }
 
-        public GetChannelGuideHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public async Task<Either<BaseError, ChannelGuide>> Handle(
+        GetChannelGuide request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAllForGuide()
-                .Map(channels => new ChannelGuide(request.Scheme, request.Host, channels));
+        string channelsFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        if (!_localFileSystem.FileExists(channelsFile))
+        {
+            return BaseError.New($"Required file {channelsFile} is missing");
+        }
+
+        string accessTokenUri = string.Empty;
+        if (!string.IsNullOrWhiteSpace(request.AccessToken))
+        {
+            accessTokenUri = $"?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;
+            }
+
+            string channelDataFragment = await File.ReadAllTextAsync(fileName, Encoding.UTF8, cancellationToken);
+
+            channelDataFragment = channelDataFragment
+                .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+                .Replace("{AccessTokenUri}", accessTokenUri);
+
+            channelDataFragments.Add(Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
+        }
+
+        return new ChannelGuide(_recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
     }
 }

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -1,21 +1,56 @@
-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.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
-    public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
+
+    public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAll()
+            .Map(channels => EnsureMode(channels, request.Mode))
+            .Map(
+                channels => new ChannelPlaylist(
+                    request.Scheme,
+                    request.Host,
+                    request.BaseUrl,
+                    channels,
+                    request.AccessToken));
+
+    private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
-        private readonly IChannelRepository _channelRepository;
+        var result = new List<Channel>();
+        foreach (Channel channel in channels)
+        {
+            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-legacy":
+                    channel.StreamingMode = StreamingMode.TransportStream;
+                    result.Add(channel);
+                    break;
+                case "ts":
+                    channel.StreamingMode = StreamingMode.TransportStreamHybrid;
+                    result.Add(channel);
+                    break;
+                default:
+                    result.Add(channel);
+                    break;
+            }
+        }
 
-        public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
-            _channelRepository = channelRepository;
-
-        public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll()
-                .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
+        return result;
     }
 }

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Configuration;
+
+public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : IRequest;

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -0,0 +1,31 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLibraryRefreshIntervalHandler :
+    IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateLibraryRefreshInterval request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(
+                _ => _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();
+}

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

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

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

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Emby;
+
+public record DisconnectEmby : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
+    IEmbyBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Emby;
+
+public record UpdateEmbyLibraryPreferences
+    (List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
+
+public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Emby;
+
+public record UpdateEmbyPathReplacements(
+    int EmbyMediaSourceId,
+    List<EmbyPathReplacementItem> PathReplacements) : IRequest<Either<BaseError, Unit>>;
+
+public record EmbyPathReplacementItem(int Id, string EmbyPath, string LocalPath);

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

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

ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyConnectionParametersViewModel(string Address, string ApiKey);

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

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

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

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

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

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

ErsatzTV.Application/Emby/Mapper.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Emby;
+
+public record GetAllEmbyMediaSources : IRequest<List<EmbyMediaSourceViewModel>>;