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

* remove transcode, normalize video, normalize audio settings

* cleanup

* update changelog

.config/dotnet-tools.json

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

.github/dependabot.yml

@@ -6,3 +6,21 @@ 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

@@ -0,0 +1,255 @@
+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@v2
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.0.x
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.4.5
+        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: dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.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 \
+            "ErsatzTV.dmg" \
+            "ErsatzTV.app/"
+
+      - name: Notarize
+        shell: bash
+        run: |
+          curl -o gon.zip -L -s "https://github.com/mitchellh/gon/releases/latest/download/gon_macos.zip"
+          unzip -o -q gon.zip
+          ./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
+        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@v2
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.0.x
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.4.5
+        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.0/ffmpeg-5.0-full_build.7z"
+          target: ffmpeg/
+
+      - name: Build
+        shell: bash
+        run: |
+          # Define some variables for things we need
+          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+
+          # Build everything
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.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
+            dotnet publish ErsatzTV-Windows/ErsatzTV-Windows.csproj --framework net6.0-windows --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
+          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
+        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,110 +1,58 @@
 name: Build
 on:
   workflow_dispatch:
-  pull_request:
   push:
     branches:
       - main
 jobs:
-  build_and_test:
+  calculate_version:
-    runs-on: ${{ matrix.os }}
+    name: Calculate version information
-    strategy:
+    runs-on: ubuntu-latest
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
     steps:
       - name: Get the sources
         uses: actions/checkout@v2
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --no-restore --verbosity normal
-  build_and_push:
-    name: Build & Publish to Docker Hub
-    needs: build_and_test
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no 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/prealpha/$short}"
+          final="${tag2/alpha/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
-
+      - name: Extract Artifacts Version
-      - name: Set up Docker Buildx Base
+        shell: bash
-        uses: docker/setup-buildx-action@v1
+        run: |
-        id: builder-base
+          tag=$(git describe --tags --abbrev=0)
-
+          short=$(git rev-parse --short HEAD)
-      - name: Set up Docker Buildx NVIDIA
+          final="${tag/alpha/$short}"
-        uses: docker/setup-buildx-action@v1
+          echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
-        id: builder-nvidia
+          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-
+    outputs:
-      - name: Set up Docker Buildx VAAPI
+      git_tag: ${{ env.GIT_TAG }}
-        uses: docker/setup-buildx-action@v1
+      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-        id: builder-vaapi
+      info_version: ${{ env.INFO_VERSION }}
-
+  build_and_upload:
-      - name: Login to DockerHub
+    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
-        uses: docker/login-action@v1
+    needs: calculate_version
-        with:
+    with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+      release_tag: develop
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-
+      info_version: ${{ needs.calculate_version.outputs.info_version }}
-      - name: Build and push base
+    secrets:
-        uses: docker/build-push-action@v2
+      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-        with:
+      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-          builder: ${{ steps.builder-base.outputs.name }}
+      ac_username: ${{ secrets.AC_USERNAME }}
-          context: .
+      ac_password: ${{ secrets.AC_PASSWORD }}
-          file: ./docker/Dockerfile
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
-          push: true
+  build_and_push:
-          build-args: |
+    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
-            INFO_VERSION=${{ env.GIT_TAG }}-docker
+    needs: calculate_version
-          tags: |
+    with:
-            jasongdove/ersatztv:develop
+      base_version: develop
-            jasongdove/ersatztv:${{ github.sha }}
+      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-
+      tag_version: ${{ github.sha }}
-      - name: Build and push nvidia
+    secrets:
-        uses: docker/build-push-action@v2
+      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-        with:
+      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-          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/codeql-analysis.yml

@@ -1,71 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '30 3 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'csharp' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
-        # Learn more:
-        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/docker.yml

@@ -0,0 +1,88 @@
+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
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - 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=${{ inputs.info_version }}-docker
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}
+
+      - 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=${{ inputs.info_version }}-docker-nvidia
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}-nvidia
+            jasongdove/ersatztv:${{ inputs.tag_version }}-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=${{ inputs.info_version }}-docker-vaapi
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}-vaapi
+            jasongdove/ersatztv:${{ inputs.tag_version }}-vaapi

.github/workflows/docs.yml

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

.github/workflows/pr.yml

@@ -0,0 +1,30 @@
+name: Pull Request
+on:
+  pull_request:
+jobs:
+  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@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

.github/workflows/release.yml

@@ -1,142 +1,53 @@
-name: Publish
+name: Release
 on:
   release:
     types: [ published ]
 jobs:
-  release:
+  calculate_version:
-    name: Release
+    name: Calculate version information
-    strategy:
+    runs-on: ubuntu-latest
-      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: maxOS
-            target: osx-x64
-    runs-on: ${{ matrix.os }}
     steps:
       - name: Get the sources
         uses: actions/checkout@v2
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Build
-        shell: bash
-        run: |
-          # Define some variables for things we need
-          tag=$(git describe --tags --abbrev=0)
-          release_name="ErsatzTV-$tag-${{ matrix.target }}"
-
-          # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /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/-prealpha/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV
-
+      - name: Extract Artifacts Version
-      - name: Set up Docker Buildx Base
+        shell: bash
-        uses: docker/setup-buildx-action@v1
+        run: |
-        id: builder-base
+          tag=$(git describe --tags --abbrev=0)
-
+          echo "ARTIFACTS_VERSION=${tag}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx NVIDIA
+          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-        uses: docker/setup-buildx-action@v1
+    outputs:
-        id: builder-nvidia
+      git_tag: ${{ env.GIT_TAG }}
-
+      docker_tag: ${{ env.DOCKER_TAG }}
-      - name: Set up Docker Buildx VAAPI
+      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-        uses: docker/setup-buildx-action@v1
+      info_version: ${{ env.INFO_VERSION }}
-        id: builder-vaapi
+  build_and_upload:
-
+    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
-      - name: Login to DockerHub
+    needs: calculate_version
-        uses: docker/login-action@v1
+    with:
-        with:
+      release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+      info_version: ${{ needs.calculate_version.outputs.info_version }}
-
+    secrets:
-      - name: Build and push base
+      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-        uses: docker/build-push-action@v2
+      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-        with:
+      ac_username: ${{ secrets.AC_USERNAME }}
-          builder: ${{ steps.builder-base.outputs.name }}
+      ac_password: ${{ secrets.AC_PASSWORD }}
-          context: .
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./docker/Dockerfile
+  build_and_push:
-          push: true
+    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
-          build-args: |
+    needs: calculate_version
-            INFO_VERSION=${{ env.GIT_TAG }}-docker
+    with:
-          tags: |
+      base_version: latest
-            jasongdove/ersatztv:latest
+      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-            jasongdove/ersatztv:${{ env.DOCKER_TAG }}
+      tag_version: ${{ needs.calculate_version.outputs.docker_tag }}
-
+    secrets:
-      - name: Build and push nvidia
+      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-        uses: docker/build-push-action@v2
+      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-        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

@@ -0,0 +1,22 @@
+name: Lint VueJS Files on PR Request
+on:
+  pull_request:
+jobs:
+  vue-lint:
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout the current repo
+      - name: Checkout current repository
+        uses: actions/checkout@v2
+      # Setup NodeJS version 14  
+      - name: Setup NodeJS V14.x.x
+        uses: actions/setup-node@v2
+        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,3 +43,4 @@ scripts/generate-api-sdk/swagger.json
 
 docker-compose.override.yml
 
+ErsatzTV/wwwroot/v2/

.gitmodules

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

CHANGELOG.md

@@ -5,6 +5,448 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [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
+- Show song artist in playout detail
+- Include song artist and cover art in channel guide (xmltv)
+- Use subtitles to display errors, which fixes many edge cases of unescaped characters
+- Properly split song genre tags
+- Properly display all songs that have an identical album and title
+- Fix channel logo and watermark uploads
+- Fix regression introduced with `v0.2.4-alpha` that caused some filler edge cases to crash the playout builder
+
+### Added
+- Add song genres to search index
+- Use embedded song cover art when sidecar cover art is unavailable
+
+### Changed
+- Randomly place song cover art on left or right side of screen
+- Randomly use a solid color from the cover art instead of blurred cover art for song background
+- Randomly select song detail layout (large title/small artist or small artist/title/album)
+
+## [0.3.0-alpha] - 2021-11-25
+### Fixed
+- Properly fix database incompatibility introduced with `v0.2.4-alpha` and partially fixed with `v0.2.5-alpha`
+  - The proper fix requires rebuilding all playouts, which will happen on startup after upgrading
+- Fix local library locking/progress display when adding paths
+- Fix grouping duration items in EPG when custom title is configured
+
+### Added
+- Add *experimental* `Songs` local libraries
+    - Like `Other Videos`, `Songs` require no metadata or particular folder layout, and will have tags added for each containing folder
+    - For Example, a song at `rock/band/1990 - Album/01 whatever.flac` will have the tags `rock`, `band` and `1990 - Album`, and the title `01 whatever`
+    - Songs will also have basic metadata read from embedded tags (album, artist, title)
+    - Video will be automatically generated for songs using metadata and cover art or watermarks if available
+- Add support for `.webm` video files
+
+## [0.2.5-alpha] - 2021-11-21
+### Fixed
+- Include other video title in channel guide (xmltv)
+- Fix bug introduced with 0.2.4-alpha that caused some playouts to build from year 0
+- Use less memory matching Trakt list items
+
+### Added
+- Build osx-arm64 packages on release
+
+### Changed
+- No longer warn about local Plex guids; they aren't used for Trakt matching and can be ignored
+
+## [0.2.4-alpha] - 2021-11-13
+### Changed
+- Upgrade to dotnet 6
+- Use `scale_cuda` instead of `scale_npp` for NVIDIA scaling in all cases
+
+## [0.2.3-alpha] - 2021-11-03
+### Fixed
+- Fix bug with audio filter in cultures where `.` is a group/thousands separator
+- Fix bug where flood playout mode would only schedule one item
+  - This would happen if the flood was followed by another flood with a fixed start time
+
+### Added
+- Support empty `.etvignore` file to instruct local movie scanner to ignore the containing folder
+
+## [0.2.2-alpha] - 2021-10-30
+### Fixed
+- Fix EPG entries for Duration schedule items that play multiple items
+- Fix EPG entries for Multiple schedule items that play more than one item
+
+### Added
+- Add fallback filler settings to Channel and global FFmpeg Settings
+  - When streaming is attempted during an unscheduled gap, the resulting video will be determined using the following priority:
+    - Channel fallback filler
+    - Global fallback filler
+    - Generated `Channel Is Offline` error message video 
+
+### Changed
+- Allow per-episode folders for local show libraries
+  - e.g. `Show Name\Season #\Episode #\Show Name - s#e#.mkv`
+
+## [0.2.1-alpha] - 2021-10-24
+### Fixed
+- Fix saving dynamic start time on schedule items
+
+## [0.2.0-alpha] - 2021-10-23
+### Fixed
+- Fix generated streams with mpeg2video
+- Fix incorrect row count in playout detail table
+- Fix deleting movies that have been removed from Jellyfin and Emby
+- Fix bug that caused large unscheduled gaps in playouts
+  - This was caused by schedule items with a fixed start of midnight
+
+### Added
+- Add new filler system
+    - `Pre-Roll Filler` plays before each media item
+    - `Mid-Roll Filler` plays between media item chapters
+    - `Post-Roll Filler` plays after each media item
+    - `Tail Filler` plays after all media items, until the next media item
+    - `Fallback Filler` loops instead of default offline image to fill any remaining gaps
+- Store chapter details with media statistics; this is needed to support mid-roll filler
+    - This requires re-ingesting statistics for all media items the first time this version is launched
+- Add switch to show/hide filler in playout detail table
+- Add `minutes` field to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Change some debug log messages to info so they show by default again
+- Remove tail collection options from `Duration` playout mode
+- Show localized start time in schedule items tables
+
+## [0.1.5-alpha] - 2021-10-18
+### Fixed
+- Fix double scheduling; this could happen if the app was shutdown during a playout build
+- Fix updating Jellyfin and Emby TV seasons
+- Fix updating Jellyfin and Emby artwork
+- Fix Plex, Jellyfin, Emby worker crash attempting to sync library that no longer exists
+- Fix bug with `Duration` mode scheduling when media items are too long to fit in the requested duration
+
+### Added
+- Include music video thumbnails in channel guide (xmltv)
+
+### Changed
+- Automatically find working Plex address on startup
+- Automatically select schedule item in schedules that contain only one item
+- Change default log level from `Debug` to `Information`
+  - The `Debug` log level can be enabled in the `appsettings.json` file for non-docker installs
+  - The `Debug` log level can be enabled by setting the environment variable `Serilog:MinimumLevel=Debug` for docker installs
+
+## [0.1.4-alpha] - 2021-10-14
+### Fixed
+- Fix error message/offline stream continuity with channels that use HLS Segmenter
+- Fix removing items from search index when folders are removed from local libraries
+
+### Added
+- Add `Other Video` local libraries
+  - Other video items require no metadata or particular folder layout, and will have tags added for each containing folder
+  - For Example, a video at `commercials/sd/1990/whatever.mkv` will have the tags `commercials`, `sd` and `1990`, and the title `whatever`
+- Add filler `Tail Mode` option to `Duration` playout mode (in addition to existing `Offline` option)
+  - Filler collection will always be randomized (to fill as much time as possible)
+  - Filler will be hidden from channel guide, but visible in playout details in ErsatzTV
+  - Unfilled time will show offline image
+- Add `Guide Mode` option to all schedule items
+  - `Normal` guide mode will show all scheduled items in the channel guide (xmltv)
+  - `Filler` guide mode will hide all scheduled items from the channel guide, and extend the end time for the previous item in the guide
+
+## [0.1.3-alpha] - 2021-10-13
+### Fixed
+- Fix startup bug for some docker installations
+
+## [0.1.2-alpha] - 2021-10-12
+### Added
+- Include more cuda (nvidia) filters in docker image
+- Enable deinterlacing with nvidia using new `yadif_cuda` filter
+- Add two HLS Segmenter settings: idle timeout and work-ahead limit
+  - `HLS Segmenter Idle Timeout` - the number of seconds to keep transcoding a channel while no requests have been received from any client
+    - This setting must be greater than or equal to 30 (seconds)
+  - `Work-Ahead HLS Segmenter Limit` - the number of segmenters (channels) that will work-ahead simultaneously (if multiple channels are being watched)
+    - "working ahead" means transcoding at full speed, which can take a lot of resources
+    - This setting must be greater than or equal to 0
+- Add more watermark locations ("middle" of each side)
+- Add `VAAPI Device` setting to ffmpeg profile to support installations with multiple video cards
+- Add *experimental* `RadeonSI` option for `VAAPI Driver` and include mesa drivers in vaapi docker image
+
+### Changed
+- Upgrade ffmpeg from 4.3 to 4.4 in all docker images
+  - Upgrading from 4.3 to 4.4 is recommended for all installations
+- Move `VAAPI Driver` from settings page to ffmpeg profile to support installations with multiple video cards
+
+### Fixed
+- Fix some transcoding edge cases with nvidia and pixel format `yuv420p10le`
+
+## [0.1.1-alpha] - 2021-10-10
+### Added
+- Add music video album to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove forced initial delay from `HLS Segmenter` streaming mode
+- Upgrade nvidia docker image from 18.04 to 20.04
+
+## [0.1.0-alpha] - 2021-10-08
+### Added
+- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`) 
+  - This mode is intended to increase client compatibility and reduce issues at program boundaries
+  - If you want the temporary transcode files to be located on a particular drive, the docker path is `/root/.local/share/etv-transcode`
+- Store frame rate with media statistics; this is needed to support HLS Segmenter
+  - This requires re-ingesting statistics for all media items the first time this version is launched
+
+### Changed
+- Use latest iHD driver (21.2.3 vs 20.1.1) in vaapi docker images
+
+### Fixed
+- Add downsampling to support transcoding 10-bit HEVC content with the h264_vaapi encoder
+- Fix updating statistics when media items are replaced
+- Fix XMLTV generation when scheduled episode is missing metadata
+
+## [0.0.62-alpha] - 2021-10-05
+### Added
+- Support IMDB ids from Plex libraries, which may improve Trakt matching for some items
+
+### Fixed
+- Include Specials/Season 0 `episode-num` entry in XMLTV
+- Fix some transcoding edge cases with VAAPI and pixel formats `yuv420p10le`, `yuv444p10le` and `yuv444p`
+- Update Plex movie and episode paths when they are changed within Plex
+- Always use `libx264` software encoder for error messages
+
+## [0.0.61-alpha] - 2021-09-30
+### Fixed
+- Revert nvenc/cuda filter change from v60
+
+## [0.0.60-alpha] - 2021-09-25
+### Added
+- Add Trakt list support under `Lists` > `Trakt Lists`
+  - Trakt lists can be added by url or by `user/list`
+  - To re-download a Trakt list, simply add it again (no need to delete)
+  - See `Logs` for unmatched item details
+  - Trakt lists can only be scheduled by using Smart Collections
+- Add seasons to search index
+  - This is needed because Trakt lists can contain seasons 
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Fixed
+- Fix local television scanner to properly update episode metadata when NFO files have been added/changed
+- Properly detect ffmpeg nvenc (cuda) support in Hardware Acceleration health check
+- Fix nvenc/cuda filter for some yuv420p content
+
+## [0.0.59-alpha] - 2021-09-18
+### Added
+- Add `Health Checks` table to home page to identify and surface common misconfigurations
+  - `FFmpeg Version` checks `ffmpeg` and `ffprobe` versions
+  - `FFmpeg Reports` checks whether ffmpeg troubleshooting reports are enabled since they can use a lot of disk space over time
+  - `Hardware Acceleration` checks whether channels that transcode are using acceleration methods that ffmpeg claims to support
+  - `Movie Metadata` checks whether all movies have metadata (fallback metadata counts as metadata)
+  - `Episode Metadata` checks whether all episodes have metadata (fallback metadata counts as metadata)
+  - `Zero Duration` checks whether all movies and episodes have a valid (non-zero) duration
+  - `VAAPI Driver` checks whether a vaapi driver preference is configured when using the vaapi docker image
+- Add setting to each playout to schedule an automatic daily rebuild
+  - This is useful if the playout uses a smart collection with `released_onthisday`
+
+### Fixed
+- Fix docker vaapi support for newer Intel platforms (Gen 8+)
+  - This includes a new setting to force a particular vaapi driver (`iHD` or `i965`), as some Gen 8 or 9 hardware that is supported by both drivers will perform better with one or the other
+- Fix scanning and indexing local movies and episodes without NFO metadata
+- Fix displaying seasons for shows with no year (in metadata or in folder name)
+- Fix "direct play" in MPEG-TS mode (copy audio and video stream when `Transcode` is unchecked)
+
 ## [0.0.58-alpha] - 2021-09-15
 ### Added
 - Add `released_notinthelast` search field for relative release date queries
@@ -594,8 +1036,39 @@ 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.0.58-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.5-alpha...HEAD
-[0.0.58-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.57-alpha...v0.0.57-alpha
+[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
+[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
+[0.2.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.3-alpha...v0.2.4-alpha
+[0.2.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.2-alpha...v0.2.3-alpha
+[0.2.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.1-alpha...v0.2.2-alpha
+[0.2.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.0-alpha...v0.2.1-alpha
+[0.2.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.5-alpha...v0.2.0-alpha
+[0.1.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...v0.1.5-alpha
+[0.1.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...v0.1.4-alpha
+[0.1.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.2-alpha...v0.1.3-alpha
+[0.1.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.1-alpha...v0.1.2-alpha
+[0.1.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.0-alpha...v0.1.1-alpha
+[0.1.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.62-alpha...v0.1.0-alpha
+[0.0.62-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.61-alpha...v0.0.62-alpha
+[0.0.61-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.60-alpha...v0.0.61-alpha
+[0.0.60-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.59-alpha...v0.0.60-alpha
+[0.0.59-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.58-alpha...v0.0.59-alpha
+[0.0.58-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.57-alpha...v0.0.58-alpha
 [0.0.57-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.56-alpha...v0.0.57-alpha
 [0.0.56-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.55-alpha...v0.0.56-alpha
 [0.0.55-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.54-alpha...v0.0.55-alpha

ErsatzTV-Windows/ErsatzTV-Windows.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>WinExe</OutputType>
+        <TargetFramework>net6.0-windows</TargetFramework>
+        <RootNamespace>ErsatzTV_Windows</RootNamespace>
+        <Nullable>enable</Nullable>
+        <UseWindowsForms>true</UseWindowsForms>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <ApplicationIcon>Ersatztv.ico</ApplicationIcon>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Content Include="Ersatztv.ico">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </Content>
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="CliWrap" Version="3.4.2" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Compile Update="Program.cs">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </Compile>
+    </ItemGroup>
+
+</Project>

ErsatzTV-Windows/Program.cs

@@ -0,0 +1,14 @@
+namespace ErsatzTV_Windows;
+
+public static class Program
+{
+    /// <summary>
+    ///  The main entry point for the application.
+    /// </summary>
+    [STAThread]
+    public static void Main()
+    {
+        ApplicationConfiguration.Initialize();
+        Application.Run(new TrayApplicationContext());
+    }
+}

ErsatzTV-Windows/TrayApplicationContext.cs

@@ -0,0 +1,81 @@
+using ErsatzTV.Core;
+using System.Diagnostics;
+using CliWrap;
+
+namespace ErsatzTV_Windows;
+
+public class TrayApplicationContext : ApplicationContext
+{
+    private readonly NotifyIcon _trayIcon;
+    private readonly CancellationTokenSource _tokenSource;
+
+    public TrayApplicationContext()
+    {
+        _trayIcon = new NotifyIcon
+        {
+            Icon = new Icon("./Ersatztv.ico"),
+            ContextMenuStrip = new ContextMenuStrip(),
+            Visible = true
+        };
+
+        _tokenSource = new CancellationTokenSource();
+
+        AddMenuItem("Launch Web UI", LaunchWebUI);
+        AddMenuItem("Show Logs", ShowLogs);
+        _trayIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());
+        AddMenuItem("Exit", Exit);
+
+        string folder = AppContext.BaseDirectory;
+        string exe = Path.Combine(folder, "ErsatzTV.exe");
+
+        if (File.Exists(exe))
+        {
+
+            Cli.Wrap(exe)
+                .WithWorkingDirectory(folder)
+                .WithValidation(CommandResultValidation.None)
+                .ExecuteAsync(_tokenSource.Token);
+        }
+    }
+
+    private void AddMenuItem(string name, EventHandler action)
+    {
+        var item = new ToolStripMenuItem(name);
+        item.Click += action;
+        _trayIcon.ContextMenuStrip.Items.Add(item);
+    }
+
+    private void LaunchWebUI(object? sender, EventArgs e)
+    {
+        var process = new Process();
+        process.StartInfo.UseShellExecute = true;
+        process.StartInfo.FileName = "http://localhost:8409";
+        process.Start();
+    }
+
+    private void ShowLogs(object? sender, EventArgs e)
+    {
+        if (!Directory.Exists(FileSystemLayout.LogsFolder))
+        {
+            Directory.CreateDirectory(FileSystemLayout.LogsFolder);
+        }
+
+        var process = new Process();
+        process.StartInfo.UseShellExecute = true;
+        process.StartInfo.FileName = FileSystemLayout.LogsFolder;
+        process.Start();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        _tokenSource?.Cancel();
+        base.Dispose(disposing);
+    }
+
+    private void Exit(object? sender, EventArgs e)
+    {
+        // Hide tray icon, otherwise it will remain shown until user mouses over it
+        _trayIcon.Visible = false;
+        Application.Exit();
+    }
+}

ErsatzTV.Application/Artists/ArtistViewModel.cs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

@@ -1,29 +1,22 @@
-using System.Collections.Generic;
+using ErsatzTV.Application.MediaItems;
-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.Queries
+namespace ErsatzTV.Application.Artists;
+
+public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
 {
-    public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
+    private readonly IArtistRepository _artistRepository;
-    {
-        private readonly IArtistRepository _artistRepository;
 
-        public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+    public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
 
-        public Task<List<NamedMediaItemViewModel>> Handle(
+    public Task<List<NamedMediaItemViewModel>> Handle(
-            GetAllArtists request,
+        GetAllArtists request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            _artistRepository.GetAllArtists()
+        _artistRepository.GetAllArtists()
-                .Map(
+            .Map(
-                    list => list.Filter(
+                list => list.Filter(
-                        a => !string.IsNullOrWhiteSpace(
+                    a => !string.IsNullOrWhiteSpace(
-                            a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
+                        a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+            .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
+}
-}

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -1,38 +1,32 @@
-using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
-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.Queries
+namespace ErsatzTV.Application.Artists;
+
+public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
 {
-    public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
+    private readonly IArtistRepository _artistRepository;
+    private readonly ISearchRepository _searchRepository;
+
+    public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
     {
-        private readonly IArtistRepository _artistRepository;
+        _artistRepository = artistRepository;
-        private readonly ISearchRepository _searchRepository;
+        _searchRepository = searchRepository;
-
-        public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
-        {
-            _artistRepository = artistRepository;
-            _searchRepository = searchRepository;
-        }
-
-        public async Task<Option<ArtistViewModel>> Handle(
-            GetArtistById request,
-            CancellationToken cancellationToken)
-        {
-            Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
-            return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
-                async artist =>
-                {
-                    List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                    List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
-                    return ProjectToViewModel(artist, languageCodes);
-                },
-                () => Task.FromResult(Option<ArtistViewModel>.None));
-        }
     }
-}
+
+    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,14 +1,17 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
-{
+
-    public record ChannelViewModel(
+public record ChannelViewModel(
-        int Id,
+    int Id,
-        string Number,
+    string Number,
-        string Name,
+    string Name,
-        int FFmpegProfileId,
+    string Group,
-        string Logo,
+    string Categories,
-        string PreferredLanguageCode,
+    int FFmpegProfileId,
-        StreamingMode StreamingMode,
+    string Logo,
-        int? WatermarkId);
+    string PreferredLanguageCode,
-}
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int PlayoutCount);

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

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

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,135 +1,155 @@
-using System;
+using System.Globalization;
-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.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
 {
-    public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateChannelResult>> Handle(
+        CreateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+        return await LanguageExtensions.Apply(validation, c => PersistChannel(dbContext, c));
-
-        public async Task<Either<BaseError, CreateChannelResult>> Handle(
-            CreateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistChannel(dbContext, c));
-        }
-
-        private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
-        {
-            await dbContext.Channels.AddAsync(channel);
-            await dbContext.SaveChangesAsync();
-            return new CreateChannelResult(channel.Id);
-        }
-
-        private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
-            (ValidateName(request), await ValidateNumber(dbContext, request),
-                await FFmpegProfileMustExist(dbContext, request),
-                ValidatePreferredLanguage(request),
-                await WatermarkMustExist(dbContext, request))
-            .Apply(
-                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId) =>
-                {
-                    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;
-                    }
-
-                    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<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
+    {
+        await dbContext.Channels.AddAsync(channel);
+        await dbContext.SaveChangesAsync();
+        return new CreateChannelResult(channel.Id);
+    }
+
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request),
+            await FFmpegProfileMustExist(dbContext, request),
+            ValidatePreferredLanguage(request),
+            await WatermarkMustExist(dbContext, request),
+            await FillerPresetMustExist(dbContext, request))
+        .Apply(
+            (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId, fillerPresetId) =>
+            {
+                var artwork = new List<Artwork>();
+                if (!string.IsNullOrWhiteSpace(request.Logo))
+                {
+                    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,
+                    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,4 +1,3 @@
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
-{
+
-    public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);
+public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);
-}

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,121 +1,115 @@
-using System;
+using System.Globalization;
-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.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
-    public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, ChannelViewModel>> Handle(
+        UpdateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, ChannelViewModel>> Handle(
-            UpdateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
-        {
-            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 =>
-                    {
-                        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;
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(c);
-        }
-
-        private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
-            (await ChannelMustExist(dbContext, request), ValidateName(request),
-                await ValidateNumber(dbContext, request),
-                ValidatePreferredLanguage(request))
-            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
-
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(
-            TvContext dbContext,
-            UpdateChannel updateChannel) =>
-            dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
-            updateChannel.NotEmpty(c => c.Name)
-                .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(
-            TvContext dbContext,
-            UpdateChannel updateChannel)
-        {
-            int matchId = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
-                .Match(c => c.Id, () => updateChannel.ChannelId);
-
-            if (matchId == updateChannel.ChannelId)
-            {
-                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
-                {
-                    return updateChannel.Number;
-                }
-
-                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-            }
-
-            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 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.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 =>
+                {
+                    artwork.Path = update.Logo;
+                    artwork.DateUpdated = DateTime.UtcNow;
+                },
+                () =>
+                {
+                    var artwork = new Artwork
+                    {
+                        Path = update.Logo,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow,
+                        ArtworkKind = ArtworkKind.Logo
+                    };
+                    c.Artwork.Add(artwork);
+                });
+        }
+            
+        c.StreamingMode = update.StreamingMode;
+        c.WatermarkId = update.WatermarkId;
+        c.FallbackFillerId = update.FallbackFillerId;
+        await dbContext.SaveChangesAsync();
+        return ProjectToViewModel(c);
+    }
+
+    private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+        (await ChannelMustExist(dbContext, request), ValidateName(request),
+            await ValidateNumber(dbContext, request),
+            ValidatePreferredLanguage(request))
+        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        UpdateChannel updateChannel) =>
+        dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
+        updateChannel.NotEmpty(c => c.Name)
+            .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        UpdateChannel updateChannel)
+    {
+        int matchId = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
+            .Match(c => c.Id, () => updateChannel.ChannelId);
+
+        if (matchId == updateChannel.ChannelId)
+        {
+            if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+            {
+                return updateChannel.Number;
+            }
+
+            return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+        }
+
+        return BaseError.New("Channel number must be unique");
+    }
+
+    private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+        Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred language code is invalid");
+}

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,28 +1,45 @@
-using System.Linq;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-    {
+        new(
-        internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
+            channel.Id,
-            new(
+            channel.Number,
-                channel.Id,
+            channel.Name,
-                channel.Number,
+            channel.Group,
-                channel.Name,
+            channel.Categories,
-                channel.FFmpegProfileId,
+            channel.FFmpegProfileId,
-                GetLogo(channel),
+            GetLogo(channel),
-                channel.PreferredLanguageCode,
+            channel.PreferredLanguageCode,
-                channel.StreamingMode,
+            channel.StreamingMode,
-                channel.WatermarkId);
+            channel.WatermarkId,
+            channel.FallbackFillerId,
+            channel.Playouts?.Count ?? 0);
 
-        private static string GetLogo(Channel channel) =>
+    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+        new(
-                .Match(a => a.Path, string.Empty);
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.FFmpegProfile.Name,
+            channel.PreferredLanguageCode,
+            GetStreamingMode(channel));
 
-        private static string GetWatermark(Channel channel) =>
+    private static string GetLogo(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-                .Match(a => a.Path, string.Empty);
+            .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()
+        };
+}

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -0,0 +1,102 @@
+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)
+    {
+        // TODO: expand to check everything in collection rather than what's scheduled?
+        _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        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,7 +1,5 @@
 using ErsatzTV.Core.Iptv;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
-{
+
-    public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
+public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
-}

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -1,33 +1,28 @@
-using System.Threading;
+using ErsatzTV.Core;
-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.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLibraryRefreshIntervalHandler :
+    MediatR.IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
 {
-    public class UpdateLibraryRefreshIntervalHandler :
+    private readonly IConfigElementRepository _configElementRepository;
-        MediatR.IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
 
-        public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+    public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+        _configElementRepository = configElementRepository;
 
-        public Task<Either<BaseError, Unit>> Handle(
+    public Task<Either<BaseError, Unit>> Handle(
-            UpdateLibraryRefreshInterval request,
+        UpdateLibraryRefreshInterval request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            Validate(request)
+        Validate(request)
-                .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval))
+            .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval))
-                .Bind(v => v.ToEitherAsync());
+            .Bind(v => v.ToEitherAsync());
 
-        private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
+    private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
-            Optional(request.LibraryRefreshInterval)
+        Optional(request.LibraryRefreshInterval)
-                .Filter(lri => lri > 0)
+            .Where(lri => lri > 0)
-                .Map(_ => Unit.Default)
+            .Map(_ => Unit.Default)
-                .ToValidation<BaseError>("Tuner count must be greater than zero")
+            .ToValidation<BaseError>("Tuner count must be greater than zero")
-                .AsTask();
+            .AsTask();
-    }
+}
-}

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

@@ -1,66 +1,59 @@
-using System.Collections.Generic;
+using System.Threading.Channels;
-using System.Linq;
+using ErsatzTV.Application.Playouts;
-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
+namespace ErsatzTV.Application.Configuration;
+
+public class
+    UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
 {
-    public class
+    private readonly IConfigElementRepository _configElementRepository;
-        UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+    public UpdatePlayoutDaysToBuildHandler(
+        IConfigElementRepository configElementRepository,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
     {
-        private readonly IConfigElementRepository _configElementRepository;
+        _configElementRepository = configElementRepository;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
-        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+        _workerChannel = 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)
-                .Filter(days => days > 0)
-                .Map(_ => Unit.Default)
-                .ToValidation<BaseError>("Days to build must be greater than zero")
-                .AsTask();
     }
-}
+
+    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/ConfigElementViewModel.cs

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

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

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

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -1,60 +1,56 @@
-using System.Threading;
+using System.Threading.Channels;
-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.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
 {
-    public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+    private readonly IEmbyApiClient _embyApiClient;
+    private readonly IEmbySecretStore _embySecretStore;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SaveEmbySecretsHandler(
+        IEmbySecretStore embySecretStore,
+        IEmbyApiClient embyApiClient,
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        _embySecretStore = embySecretStore;
-        private readonly IEmbyApiClient _embyApiClient;
+        _embyApiClient = embyApiClient;
-        private readonly IEmbySecretStore _embySecretStore;
+        _mediaSourceRepository = mediaSourceRepository;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        _channel = channel;
-
-        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,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
-{
+
-    public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IEmbyBackgroundServiceRequest;
+    IEmbyBackgroundServiceRequest;
-}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -1,118 +1,111 @@
-using System.Collections.Generic;
+using ErsatzTV.Core;
-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.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class
+    SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
 {
-    public class
+    private readonly IEmbyApiClient _embyApiClient;
-        SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
+    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)
     {
-        private readonly IEmbyApiClient _embyApiClient;
+        _mediaSourceRepository = mediaSourceRepository;
-        private readonly IEmbySecretStore _embySecretStore;
+        _embySecretStore = embySecretStore;
-        private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
+        _embyApiClient = embyApiClient;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        _logger = logger;
-        private readonly ISearchIndex _searchIndex;
+        _searchIndex = searchIndex;
-
-        public SynchronizeEmbyLibrariesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbySecretStore embySecretStore,
-            IEmbyApiClient embyApiClient,
-            ILogger<SynchronizeEmbyLibrariesHandler> logger,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _embySecretStore = embySecretStore;
-            _embyApiClient = embyApiClient;
-            _logger = logger;
-            _searchIndex = searchIndex;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            SynchronizeEmbyLibraries request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(SynchronizeLibraries)
-                .Bind(v => v.ToEitherAsync());
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
-            MediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
-            SynchronizeEmbyLibraries request) =>
-            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-                .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            EmbyMediaSource embyMediaSource)
-        {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(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);
-
-            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; }
-        }
     }
-}
+
+    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);
+
+        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,23 +1,20 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
+    IEmbyBackgroundServiceRequest
 {
-    public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
+    int EmbyLibraryId { get; }
-        IEmbyBackgroundServiceRequest
+    bool ForceScan { get; }
-    {
-        int EmbyLibraryId { get; }
-        bool ForceScan { get; }
-    }
-
-    public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
-    {
-        public bool ForceScan => false;
-    }
-
-    public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
-    {
-        public bool ForceScan => true;
-    }
 }
+
+public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+{
+    public bool ForceScan => false;
+}
+
+public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+{
+    public bool ForceScan => true;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -1,181 +1,184 @@
-using System;
+using ErsatzTV.Core;
-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
+namespace ErsatzTV.Application.Emby;
+
+public class SynchronizeEmbyLibraryByIdHandler :
+    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
 {
-    public class SynchronizeEmbyLibraryByIdHandler :
+    private readonly IConfigElementRepository _configElementRepository;
-        IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
-        IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+
+    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)
     {
-        private readonly IConfigElementRepository _configElementRepository;
+        _mediaSourceRepository = mediaSourceRepository;
-        private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
+        _embySecretStore = embySecretStore;
+        _embyMovieLibraryScanner = embyMovieLibraryScanner;
+        _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
+        _libraryRepository = libraryRepository;
+        _entityLocker = entityLocker;
+        _configElementRepository = configElementRepository;
+        _logger = logger;
+    }
 
-        private readonly IEmbySecretStore _embySecretStore;
+    public Task<Either<BaseError, string>> Handle(
-        private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
+        ForceSynchronizeEmbyLibraryById request,
-        private readonly IEntityLocker _entityLocker;
+        CancellationToken cancellationToken) => Handle(request);
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
 
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    public Task<Either<BaseError, string>> Handle(
+        SynchronizeEmbyLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request);
 
-        public SynchronizeEmbyLibraryByIdHandler(
+    private Task<Either<BaseError, string>>
-            IMediaSourceRepository mediaSourceRepository,
+        Handle(ISynchronizeEmbyLibraryById request) =>
-            IEmbySecretStore embySecretStore,
+        Validate(request)
-            IEmbyMovieLibraryScanner embyMovieLibraryScanner,
+            .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
-            IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
+            .Bind(v => v.ToEitherAsync());
-            ILibraryRepository libraryRepository,
+
-            IEntityLocker entityLocker,
+    private async Task<Unit> Synchronize(RequestParameters parameters)
-            IConfigElementRepository configElementRepository,
+    {
-            ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
+        var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+        if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
         {
-            _mediaSourceRepository = mediaSourceRepository;
+            switch (parameters.Library.MediaKind)
-            _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(
-                    case LibraryMediaKind.Movies:
+                        parameters.ConnectionParameters.ActiveConnection.Address,
-                        await _embyMovieLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ApiKey,
-                            parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.Library,
-                            parameters.ConnectionParameters.ApiKey,
+                        parameters.FFmpegPath,
-                            parameters.Library,
+                        parameters.FFprobePath);
-                            parameters.FFprobePath);
+                    break;
-                        break;
+                case LibraryMediaKind.Shows:
-                    case LibraryMediaKind.Shows:
+                    await _embyTelevisionLibraryScanner.ScanLibrary(
-                        await _embyTelevisionLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection.Address,
-                            parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.ConnectionParameters.ApiKey,
-                            parameters.ConnectionParameters.ApiKey,
+                        parameters.Library,
-                            parameters.Library,
+                        parameters.FFmpegPath,
-                            parameters.FFprobePath);
+                        parameters.FFprobePath);
-                        break;
+                    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);
+            parameters.Library.LastScan = DateTime.UtcNow;
-            return Unit.Default;
+            await _libraryRepository.UpdateLastScan(parameters.Library);
+        }
+        else
+        {
+            _logger.LogDebug(
+                "Skipping unforced scan of emby media library {Name}",
+                parameters.Library.Name);
         }
 
-        private async Task<Validation<BaseError, RequestParameters>> Validate(
+        _entityLocker.UnlockLibrary(parameters.Library.Id);
-            ISynchronizeEmbyLibraryById request) =>
+        return Unit.Default;
-            (await ValidateConnection(request), await EmbyLibraryMustExist(request),
+    }
-                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+
-            .Apply(
+    private async Task<Validation<BaseError, RequestParameters>> Validate(
-                (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
+        ISynchronizeEmbyLibraryById request) =>
+        (await ValidateConnection(request), await EmbyLibraryMustExist(request),
+            await ValidateLibraryRefreshInterval(), await ValidateFFmpegPath(), await ValidateFFprobePath())
+        .Apply(
+            (connectionParameters, embyLibrary, libraryRefreshInterval, ffmpegPath, ffprobePath) =>
+                new RequestParameters(
                     connectionParameters,
                     embyLibrary,
                     request.ForceScan,
                     libraryRefreshInterval,
+                    ffmpegPath,
                     ffprobePath
                 ));
 
-        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+    private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
-            ISynchronizeEmbyLibraryById request) =>
+        ISynchronizeEmbyLibraryById request) =>
-            EmbyMediaSourceMustExist(request)
+        EmbyMediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
+            .BindT(MediaSourceMustHaveApiKey);
 
-        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-            ISynchronizeEmbyLibraryById request) =>
+        ISynchronizeEmbyLibraryById request) =>
-            _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
+        _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
-                .Map(
+            .Map(
-                    v => v.ToValidation<BaseError>(
+                v => v.ToValidation<BaseError>(
-                        $"Emby media source for library {request.EmbyLibraryId} does not exist."));
+                    $"Emby media source for library {request.EmbyLibraryId} does not exist."));
 
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            EmbyMediaSource embyMediaSource)
+        EmbyMediaSource embyMediaSource)
-        {
+    {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+        Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active 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)
-                .Filter(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; }
-        }
     }
-}
+
+    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>> ValidateFFmpegPath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
+            .FilterT(File.Exists)
+            .Map(
+                ffmpegPath =>
+                    ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
+
+    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 FFmpegPath,
+        string FFprobePath);
+
+    private record ConnectionParameters(
+        EmbyMediaSource EmbyMediaSource,
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -1,41 +1,35 @@
-using System.Collections.Generic;
+using System.Threading.Channels;
-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.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
+    Either<BaseError, List<EmbyMediaSource>>>
 {
-    public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
+    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
-        Either<BaseError, List<EmbyMediaSource>>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SynchronizeEmbyMediaSourcesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        _mediaSourceRepository = mediaSourceRepository;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        _channel = channel;
-
-        public SynchronizeEmbyMediaSourcesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _channel = channel;
-        }
-
-        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;
-        }
     }
-}
+
+    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,11 +1,8 @@
-using System.Collections.Generic;
+using ErsatzTV.Core;
-using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
-{
-    public record UpdateEmbyLibraryPreferences
-        (List<EmbyLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
 
-    public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);
+public record UpdateEmbyLibraryPreferences
-}
+    (List<EmbyLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs

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

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -1,55 +1,49 @@
-using System.Collections.Generic;
+using ErsatzTV.Core;
-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.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
+    Either<BaseError, Unit>>
 {
-    public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
+    private readonly IMediaSourceRepository _mediaSourceRepository;
-        Either<BaseError, Unit>>
+
+    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)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
 
-        public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+        var incoming = request.PathReplacements.Map(Project).ToList();
-            _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<Either<BaseError, Unit>> Handle(
+        var toAdd = incoming.Filter(r => r.Id < 1).ToList();
-            UpdateEmbyPathReplacements request,
+        var toRemove = embyMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
-            CancellationToken cancellationToken) =>
+        var toUpdate = incoming.Except(toAdd).ToList();
-            Validate(request)
-                .MapT(pms => MergePathReplacements(request, pms))
-                .Bind(v => v.ToEitherAsync());
 
-        private Task<Unit> MergePathReplacements(
+        return _mediaSourceRepository.UpdatePathReplacements(embyMediaSource.Id, toAdd, toUpdate, toRemove);
-            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,4 +1,3 @@
-namespace ErsatzTV.Application.Emby
+namespace ErsatzTV.Application.Emby;
-{
+
-    public record EmbyConnectionParametersViewModel(string Address);
+public record EmbyConnectionParametersViewModel(string Address);
-}

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

@@ -1,8 +1,7 @@
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Emby
+namespace ErsatzTV.Application.Emby;
-{
+
-    public record EmbyLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
+public record EmbyLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
-        : LibraryViewModel("Emby", Id, Name, MediaKind);
+    : LibraryViewModel("Emby", Id, Name, MediaKind);
-}

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

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

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

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

ErsatzTV.Application/Emby/Mapper.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

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

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs

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

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -1,73 +1,66 @@
-using System;
+using ErsatzTV.Core;
-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.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+    Either<BaseError, EmbyConnectionParametersViewModel>>
 {
-    public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+    private readonly IMediaSourceRepository _mediaSourceRepository;
-        Either<BaseError, EmbyConnectionParametersViewModel>>
+    private readonly IMemoryCache _memoryCache;
+
+    public GetEmbyConnectionParametersHandler(
+        IMemoryCache memoryCache,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        _memoryCache = memoryCache;
-        private readonly IMemoryCache _memoryCache;
+        _mediaSourceRepository = mediaSourceRepository;
-
-        public GetEmbyConnectionParametersHandler(
-            IMemoryCache memoryCache,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _memoryCache = memoryCache;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
-            GetEmbyConnectionParameters request,
-            CancellationToken cancellationToken)
-        {
-            if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
-            {
-                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);
     }
-}
+
+    public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
+        GetEmbyConnectionParameters request,
+        CancellationToken cancellationToken)
+    {
+        if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
+        {
+            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);
+}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs

@@ -1,7 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
-{
-    public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
-}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs

@@ -1,26 +1,19 @@
-using System.Collections.Generic;
+using ErsatzTV.Core.Interfaces.Repositories;
-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.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class
+    GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
 {
-    public class
+    private readonly IMediaSourceRepository _mediaSourceRepository;
-        GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+    public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<EmbyLibraryViewModel>> Handle(
+    public Task<List<EmbyLibraryViewModel>> Handle(
-            GetEmbyLibrariesBySourceId request,
+        GetEmbyLibrariesBySourceId request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
+        _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+            .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
+}
-}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs

@@ -1,7 +1,3 @@
-using LanguageExt;
+namespace ErsatzTV.Application.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
-{
-    public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
-}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs

@@ -1,23 +1,18 @@
-using System.Threading;
+using ErsatzTV.Core.Interfaces.Repositories;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Emby.Mapper;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class
+    GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
 {
-    public class
+    private readonly IMediaSourceRepository _mediaSourceRepository;
-        GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+    public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<Option<EmbyMediaSourceViewModel>> Handle(
+    public Task<Option<EmbyMediaSourceViewModel>> Handle(
-            GetEmbyMediaSourceById request,
+        GetEmbyMediaSourceById request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
-    }
+}
-}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -1,8 +1,4 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+public record GetEmbyPathReplacementsBySourceId
-{
+    (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
-    public record GetEmbyPathReplacementsBySourceId
-        (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
-}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs

@@ -1,26 +1,19 @@
-using System.Collections.Generic;
+using ErsatzTV.Core.Interfaces.Repositories;
-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.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
+    List<EmbyPathReplacementViewModel>>
 {
-    public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
+    private readonly IMediaSourceRepository _mediaSourceRepository;
-        List<EmbyPathReplacementViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+    public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<EmbyPathReplacementViewModel>> Handle(
+    public Task<List<EmbyPathReplacementViewModel>> Handle(
-            GetEmbyPathReplacementsBySourceId request,
+        GetEmbyPathReplacementsBySourceId request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
+        _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+            .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
+}
-}

ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs

@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
-{
+
-    public record GetEmbySecrets : IRequest<EmbySecrets>;
+public record GetEmbySecrets : IRequest<EmbySecrets>;
-}

ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs

@@ -1,19 +1,15 @@
-using System.Threading;
+using ErsatzTV.Core.Emby;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
 {
-    public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
+    private readonly IEmbySecretStore _embySecretStore;
-    {
-        private readonly IEmbySecretStore _embySecretStore;
 
-        public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
+    public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
-            _embySecretStore = embySecretStore;
+        _embySecretStore = embySecretStore;
 
-        public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
+    public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
-            _embySecretStore.ReadSecrets();
+        _embySecretStore.ReadSecrets();
-    }
+}
-}

ErsatzTV.Application/EntityIdResult.cs

@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
-{
+
-    public record EntityIdResult(int Id);
+public record EntityIdResult(int Id);
-}

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,19 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
-        <DebugType>embedded</DebugType>
+        <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="AsyncFixer" Version="1.5.1">
+      <PackageReference Include="Bugsnag" Version="3.0.0" />
-        <PrivateAssets>all</PrivateAssets>
+      <PackageReference Include="CliWrap" Version="3.4.2" />
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PackageReference Include="MediatR" Version="10.0.1" />
-      </PackageReference>
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
-      <PackageReference Include="MediatR" Version="9.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.1.46">
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -0,0 +1,43 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artists_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=health_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=images_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=images_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=jellyfin_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=jellyfin_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=libraries_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=libraries_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=logs_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=maintenance_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacards_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacollections_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacollections_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediaitems_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediasources_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=movies_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=playouts_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=playouts_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=plex_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=plex_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=resolutions_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
-{
+
-    public record CopyFFmpegProfile
+public record CopyFFmpegProfile
-        (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+    (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
-}

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs

@@ -1,37 +1,32 @@
-using System.Threading;
+using ErsatzTV.Core;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class
+    CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
 {
-    public class
+    private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
-        CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
-    {
-        private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
 
-        public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
+    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
-            _ffmpegProfileRepository = ffmpegProfileRepository;
+        _ffmpegProfileRepository = ffmpegProfileRepository;
 
-        public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
+    public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
-            CopyFFmpegProfile request,
+        CopyFFmpegProfile request,
-            CancellationToken cancellationToken) =>
+        CancellationToken cancellationToken) =>
-            Validate(request)
+        Validate(request)
-                .MapT(PerformCopy)
+            .MapT(PerformCopy)
-                .Bind(v => v.ToEitherAsync());
+            .Bind(v => v.ToEitherAsync());
 
-        private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
+    private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
-            _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
+        _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
-                .Map(ProjectToViewModel);
+            .Map(ProjectToViewModel);
 
-        private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
+    private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
-            ValidateName(request).AsTask().MapT(_ => request);
+        ValidateName(request).AsTask().MapT(_ => request);
 
-        private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
+    private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
-            request.NotEmpty(x => x.Name)
+        request.NotEmpty(x => x.Name)
-                .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+            .Bind(_ => request.NotLongerThan(50)(x => x.Name));
-    }
+}
-}

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -1,25 +1,24 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.FFmpeg;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
-{
+
-    public record CreateFFmpegProfile(
+public record CreateFFmpegProfile(
-        string Name,
+    string Name,
-        int ThreadCount,
+    int ThreadCount,
-        bool Transcode,
+    HardwareAccelerationKind HardwareAcceleration,
-        HardwareAccelerationKind HardwareAcceleration,
+    VaapiDriver VaapiDriver,
-        int ResolutionId,
+    string VaapiDevice,
-        bool NormalizeVideo,
+    int ResolutionId,
-        string VideoCodec,
+    FFmpegProfileVideoFormat VideoFormat,
-        int VideoBitrate,
+    int VideoBitrate,
-        int VideoBufferSize,
+    int VideoBufferSize,
-        string AudioCodec,
+    FFmpegProfileAudioFormat AudioFormat,
-        int AudioBitrate,
+    int AudioBitrate,
-        int AudioBufferSize,
+    int AudioBufferSize,
-        bool NormalizeLoudness,
+    bool NormalizeLoudness,
-        int AudioChannels,
+    int AudioChannels,
-        int AudioSampleRate,
+    int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
+    bool NormalizeFramerate,
-}
+    bool DeinterlaceVideo) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;