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

.config/dotnet-tools.json

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

.editorconfig

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

.github/dependabot.yml

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

.github/workflows/artifacts.yml

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

.github/workflows/ci.yml

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

.github/workflows/docker.yml

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

.github/workflows/docs.yml

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

.github/workflows/pr.yml

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

.github/workflows/release.yml

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

.github/workflows/vue-lint.yml

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

.gitignore

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

.gitmodules

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

CHANGELOG.md

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

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

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

ErsatzTV.Application/Artists/ArtistViewModel.cs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -1,22 +1,29 @@
-using ErsatzTV.Application.MediaItems;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
 using static ErsatzTV.Application.MediaItems.Mapper;
 
-namespace ErsatzTV.Application.Artists;
-
-public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+namespace ErsatzTV.Application.Artists.Queries
 {
-    private readonly IArtistRepository _artistRepository;
+    public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+    {
+        private readonly IArtistRepository _artistRepository;
 
-    public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+        public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
 
-    public Task<List<NamedMediaItemViewModel>> Handle(
-        GetAllArtists request,
-        CancellationToken cancellationToken) =>
-        _artistRepository.GetAllArtists()
-            .Map(
-                list => list.Filter(
-                    a => !string.IsNullOrWhiteSpace(
-                        a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
-            .Map(list => list.Map(ProjectToViewModel).ToList());
+        public Task<List<NamedMediaItemViewModel>> Handle(
+            GetAllArtists request,
+            CancellationToken cancellationToken) =>
+            _artistRepository.GetAllArtists()
+                .Map(
+                    list => list.Filter(
+                        a => !string.IsNullOrWhiteSpace(
+                            a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
 }

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,22 +1,15 @@
 using ErsatzTV.Core.Domain;
 
-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);
+namespace ErsatzTV.Application.Channels
+{
+    public record ChannelViewModel(
+        int Id,
+        string Number,
+        string Name,
+        int FFmpegProfileId,
+        string Logo,
+        string PreferredLanguageCode,
+        StreamingMode StreamingMode,
+        int? WatermarkId,
+        int? FallbackFillerId);
+}

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

@@ -1,15 +1,22 @@
-using ErsatzTV.Core.Hdhr;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Hdhr;
 using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
 
-namespace ErsatzTV.Application.Channels;
-
-public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
+namespace ErsatzTV.Application.Channels.Queries
 {
-    private readonly IChannelRepository _channelRepository;
+    public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
+    {
+        private readonly IChannelRepository _channelRepository;
 
-    public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+        public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-    public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAll()
-            .Map(channels => channels.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/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

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

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

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

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -1,55 +0,0 @@
-using System.Threading.Channels;
-using ErsatzTV.Application.Libraries;
-using ErsatzTV.Core;
-using ErsatzTV.FFmpeg.Runtime;
-
-namespace ErsatzTV.Application.Emby;
-
-public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler,
-    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
-    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
-{
-    public CallEmbyLibraryScannerHandler(
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo)
-        : base(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 = Validate();
-        return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
-            error => Task.FromResult<Either<BaseError, string>>(error.Join()));
-    }
-
-    private async Task<Either<BaseError, string>> PerformScan(
-        string scanner,
-        ISynchronizeEmbyLibraryById request,
-        CancellationToken cancellationToken)
-    {
-        var arguments = new List<string>
-        {
-            "scan-emby", request.EmbyLibraryId.ToString()
-        };
-
-        if (request.ForceScan)
-        {
-            arguments.Add("--force");
-        }
-
-        return await base.PerformScan(scanner, arguments, cancellationToken);
-    }
-}

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

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

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -0,0 +1,181 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SynchronizeEmbyLibraryByIdHandler :
+        IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+        IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
+
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
+        private readonly IEntityLocker _entityLocker;
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
+
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyLibraryByIdHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEmbyMovieLibraryScanner embyMovieLibraryScanner,
+            IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
+            ILibraryRepository libraryRepository,
+            IEntityLocker entityLocker,
+            IConfigElementRepository configElementRepository,
+            ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _embyMovieLibraryScanner = embyMovieLibraryScanner;
+            _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
+            _libraryRepository = libraryRepository;
+            _entityLocker = entityLocker;
+            _configElementRepository = configElementRepository;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, string>> Handle(
+            ForceSynchronizeEmbyLibraryById request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        public Task<Either<BaseError, string>> Handle(
+            SynchronizeEmbyLibraryByIdIfNeeded request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        private Task<Either<BaseError, string>>
+            Handle(ISynchronizeEmbyLibraryById request) =>
+            Validate(request)
+                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> Synchronize(RequestParameters parameters)
+        {
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
+            {
+                switch (parameters.Library.MediaKind)
+                {
+                    case LibraryMediaKind.Movies:
+                        await _embyMovieLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                    case LibraryMediaKind.Shows:
+                        await _embyTelevisionLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                }
+
+                parameters.Library.LastScan = DateTime.UtcNow;
+                await _libraryRepository.UpdateLastScan(parameters.Library);
+            }
+            else
+            {
+                _logger.LogDebug(
+                    "Skipping unforced scan of emby media library {Name}",
+                    parameters.Library.Name);
+            }
+
+            _entityLocker.UnlockLibrary(parameters.Library.Id);
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, RequestParameters>> Validate(
+            ISynchronizeEmbyLibraryById request) =>
+            (await ValidateConnection(request), await EmbyLibraryMustExist(request),
+                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+            .Apply(
+                (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
+                    connectionParameters,
+                    embyLibrary,
+                    request.ForceScan,
+                    libraryRefreshInterval,
+                    ffprobePath
+                ));
+
+        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+            ISynchronizeEmbyLibraryById request) =>
+            EmbyMediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Emby media source for library {request.EmbyLibraryId} does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Where(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Emby media source requires an api key");
+        }
+
+        private Task<Validation<BaseError, EmbyLibrary>> EmbyLibraryMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
+                .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
+
+        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+                .FilterT(lri => lri > 0)
+                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
+        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+                .FilterT(File.Exists)
+                .Map(
+                    ffprobePath =>
+                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+        private record RequestParameters(
+            ConnectionParameters ConnectionParameters,
+            EmbyLibrary Library,
+            bool ForceScan,
+            int LibraryRefreshInterval,
+            string FFprobePath);
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

@@ -1,7 +1,11 @@
-using ErsatzTV.Core;
+using System.Collections.Generic;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
 
-namespace ErsatzTV.Application.Emby;
-
-public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
-    IEmbyBackgroundServiceRequest;
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
+        IEmbyBackgroundServiceRequest;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

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

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -1,49 +1,55 @@
-using ErsatzTV.Core;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
 
-namespace ErsatzTV.Application.Emby;
-
-public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathReplacements,
-    Either<BaseError, Unit>>
+namespace ErsatzTV.Application.Emby.Commands
 {
-    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)
+    public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
+        Either<BaseError, Unit>>
     {
-        embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
+        private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        var incoming = request.PathReplacements.Map(Project).ToList();
+        public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
 
-        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();
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateEmbyPathReplacements request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(pms => MergePathReplacements(request, pms))
+                .Bind(v => v.ToEitherAsync());
 
-        return _mediaSourceRepository.UpdatePathReplacements(embyMediaSource.Id, toAdd, toUpdate, toRemove);
+        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."));
     }
-
-    private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
-        new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
-
-    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
-        EmbyMediaSourceMustExist(request);
-
-    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-        UpdateEmbyPathReplacements request) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-            .Map(
-                v => v.ToValidation<BaseError>(
-                    $"Emby media source {request.EmbyMediaSourceId} does not exist."));
 }

ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs

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

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

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

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

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

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

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

ErsatzTV.Application/Emby/Mapper.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs

@@ -1,5 +1,8 @@
 using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
 
-namespace ErsatzTV.Application.Emby;
-
-public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -1,66 +1,73 @@
-using ErsatzTV.Core;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
 using Microsoft.Extensions.Caching.Memory;
 
-namespace ErsatzTV.Application.Emby;
-
-public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
-    Either<BaseError, EmbyConnectionParametersViewModel>>
+namespace ErsatzTV.Application.Emby.Queries
 {
-    private readonly IMediaSourceRepository _mediaSourceRepository;
-    private readonly IMemoryCache _memoryCache;
-
-    public GetEmbyConnectionParametersHandler(
-        IMemoryCache memoryCache,
-        IMediaSourceRepository mediaSourceRepository)
+    public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+        Either<BaseError, EmbyConnectionParametersViewModel>>
     {
-        _memoryCache = memoryCache;
-        _mediaSourceRepository = mediaSourceRepository;
-    }
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
 
-    public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
-        GetEmbyConnectionParameters request,
-        CancellationToken cancellationToken)
-    {
-        if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
+        public GetEmbyConnectionParametersHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository)
         {
-            return parameters;
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
         }
 
-        Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
-            await Validate()
-                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
-                .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
-
-        return maybeParameters.Match(
-            p =>
+        public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
+            GetEmbyConnectionParameters request,
+            CancellationToken cancellationToken)
+        {
+            if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
             {
-                _memoryCache.Set(request, p, TimeSpan.FromHours(1));
-                return maybeParameters;
-            },
-            error => error);
+                return parameters;
+            }
+
+            Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
+                await Validate()
+                    .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                    .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
+
+            return maybeParameters.Match(
+                p =>
+                {
+                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                    return maybeParameters;
+                },
+                error => error);
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+            EmbyMediaSourceMustExist()
+                .BindT(MediaSourceMustHaveActiveConnection);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+            _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        "Emby media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection);
     }
-
-    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
-        EmbyMediaSourceMustExist()
-            .BindT(MediaSourceMustHaveActiveConnection);
-
-    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
-        _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
-            .Map(
-                v => v.ToValidation<BaseError>(
-                    "Emby media source does not exist."));
-
-    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-        EmbyMediaSource embyMediaSource)
-    {
-        Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
-        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-            .ToValidation<BaseError>("Emby media source requires an active connection");
-    }
-
-    private record ConnectionParameters(
-        EmbyMediaSource EmbyMediaSource,
-        EmbyConnection ActiveConnection);
 }